{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 实战案例：基于注意力的图像描述模型（ARCTIC）\n",
    "\n",
    "## 模型训练流程\n",
    "\n",
    "![模型训练的一般流程](img/cr-traning_process.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "在现代的深度学习框架基础下，模型训练的一般流程包括读取数据、前馈计算、计算损失、更新参数、选择模型五个步骤。每个步骤需要实现相应的模块。\n",
    "\n",
    "- 在读取数据阶段，我们首先需要下载数据集，然后对整理数据集的格式，以方便接下来构造数据集类，最后在数据集类的基础上构建能够按批次产生训练、验证和测试数据的对象。\n",
    "\n",
    "- 在前馈计算阶段，我们需要实现具体的模型，使得模型能够根据输入产生相应的输出。\n",
    "\n",
    "- 在计算损失阶段，我们需要将模型输出和预期输出进行对比，实现损失函数。\n",
    "\n",
    "- 在更新参数阶段，我们需要给出具体的参数更新方法，即优化方法；由于现代深度学习框架能够自动计算参数梯度，并实现了绝大多数优化方法，我们通常只需要从中进行选择即可。\n",
    "\n",
    "- 在选择模型阶段，我们需要实现具体的评估指标，选出在验证集上表现最优的模型参数。\n",
    "\n",
    "下面，我们将按照这个次序介绍一个图像编码器为CNN网格表示提取器、文本解码器为RNN+注意力的图像描述方法的具体实现。我们的实现大体上是在复现ARCTIC模型，但是在细节上有一些改变，下面的实现过程会对这些改变做具体说明。此外，[链接](https://github.com/sgrvinod/a-PyTorch-Tutorial-to-Image-Captioning)给出了一个更接近原始ARCTIC模型的代码库，非常推荐大家阅读。本节的部分代码也是受到该代码库的启发。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 读取数据\n",
    "\n",
    "### 下载数据集\n",
    "\n",
    "- 我们使用的数据集为flickr8k([下载地址](https://www.kaggle.com/adityajn105/flickr8k))。\n",
    "- 下载解压后，将其图片放在指定目录(本代码中将该目录设置为../data/flickr8k)下的images文件夹里。\n",
    "- 数据集包括8000张图片，每张图片对应5个句子描述。\n",
    "- 数据集划分采用Karpathy提供的方法([下载地址](http://cs.stanford.edu/people/karpathy/deepimagesent/caption_datasets.zip))，下载解压后，将其中的dataset_flickr8k.json文件拷贝到指定目录下。该划分方法将数据集分成3个子集：6,000张图片和其对应句子描述组成训练集，1,000张图片和描述为验证集，剩余的1,000张图片和描述为测试集。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 整理数据集\n",
    "\n",
    "数据集下载完成后，我们需要对其进行处理，以适合之后构造的PyTorch数据集类读取。\n",
    "- 对于文本描述，我们首先构建词典，然后根据词典将文本描述转化为向量。\n",
    "- 对于图像，我们这里仅记录文件路径。\n",
    "- - 如果机器的内存和硬盘空间就比较大，这里也可以将图片读取并处理成三维数组，这样在模型训练和测试的阶段，就不需要再直接读取图片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import os\n",
    "import json\n",
    "import random \n",
    "from collections import defaultdict, Counter\n",
    "from PIL import Image\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def create_dataset(dataset='flickr8k',\n",
    "                   captions_per_image=5, \n",
    "                   min_word_count=5, \n",
    "                   max_len=30):\n",
    "    \"\"\"\n",
    "    参数：\n",
    "        dataset：数据集名称\n",
    "        captions_per_image：每张图片对应的文本描述数\n",
    "        min_word_count：仅考虑在数据集中（除测试集外）出现5次的词\n",
    "        max_len：文本描述包含的最大单词数，如果文本描述超过该值，则截断\n",
    "    输出：\n",
    "        一个词典文件： vocab.json\n",
    "        三个数据集文件： train_data.json、 val_data.json、 test_data.json\n",
    "    \"\"\"\n",
    "\n",
    "    karpathy_json_path='../data/%s/dataset_flickr8k.json' % dataset\n",
    "    image_folder='../data/%s/images' % dataset\n",
    "    output_folder='../data/%s' % dataset\n",
    "\n",
    "    with open(karpathy_json_path, 'r') as j:\n",
    "        data = json.load(j)\n",
    "    \n",
    "    image_paths = defaultdict(list)\n",
    "    image_captions = defaultdict(list)\n",
    "    vocab = Counter()\n",
    "\n",
    "    for img in data['images']:\n",
    "        split = img['split']\n",
    "        captions = []\n",
    "        for c in img['sentences']:\n",
    "            # 更新词频，测试集在训练过程中是未见数据集，不能统计\n",
    "            if split != 'test':\n",
    "                vocab.update(c['tokens'])\n",
    "            # 不统计超过最大长度限制的词\n",
    "            if len(c['tokens']) <= max_len:\n",
    "                captions.append(c['tokens'])\n",
    "        if len(captions) == 0:\n",
    "            continue\n",
    "\n",
    "        path = os.path.join(image_folder, img['filename'])\n",
    "        \n",
    "        image_paths[split].append(path)\n",
    "        image_captions[split].append(captions)\n",
    "\n",
    "    # 创建词典，增加占位标识符<pad>、未登录词标识符<unk>、句子首尾标识符<start>和<end>\n",
    "    words = [w for w in vocab.keys() if vocab[w] > min_word_count]\n",
    "    vocab = {k: v + 1 for v, k in enumerate(words)}\n",
    "    vocab['<pad>'] = 0\n",
    "    vocab['<unk>'] = len(vocab)\n",
    "    vocab['<start>'] = len(vocab)\n",
    "    vocab['<end>'] = len(vocab)\n",
    "\n",
    "    # 存储词典\n",
    "    with open(os.path.join(output_folder, 'vocab.json'), 'w') as fw:\n",
    "        json.dump(vocab, fw)\n",
    "\n",
    "    # 整理数据集\n",
    "    for split in image_paths:\n",
    "        imgpaths = image_paths[split]\n",
    "        imcaps = image_captions[split]\n",
    "        \n",
    "        enc_captions = []\n",
    "\n",
    "        for i, path in enumerate(imgpaths):\n",
    "            # 合法性检查，检查图像是否可以被解析\n",
    "            img = Image.open(path) \n",
    "            # 如果该图片对应的描述数量不足，则补足\n",
    "            if len(imcaps[i]) < captions_per_image:\n",
    "                captions = imcaps[i] + \\\n",
    "                    [random.choice(imcaps[i]) for _ in range(captions_per_image - len(imcaps[i]))]\n",
    "            # 如果该图片对应的描述数量超了，则随机采样\n",
    "            else:\n",
    "                captions = random.sample(imcaps[i], k=captions_per_image)\n",
    "            assert len(captions) == captions_per_image\n",
    "            \n",
    "            for j, c in enumerate(captions):\n",
    "                # 对文本描述进行编码\n",
    "                enc_c = [vocab['<start>']] + [vocab.get(word, vocab['<unk>']) for word in c] + [vocab['<end>']] \n",
    "                enc_captions.append(enc_c)\n",
    "        # 合法性检查\n",
    "        assert len(imgpaths) * captions_per_image == len(enc_captions)\n",
    "        \n",
    "        # 存储数据\n",
    "        data = {'IMAGES': imgpaths, \n",
    "                'CAPTIONS': enc_captions}\n",
    "        with open(os.path.join(output_folder, split + '_data.json'), 'w') as fw:\n",
    "            json.dump(data, fw)\n",
    "\n",
    "# create_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "在调用该函数生成需要的格式的数据集文件之后，我们可以展示其中一条数据，简单验证下数据的格式是否和我们预想的一致。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<start> a dog splashes in the murky water <end>\n",
      "<start> a black dog is shaking water off his body <end>\n",
      "<start> black dog in the water shaking the water off of him <end>\n",
      "<start> a dog on a leash shakes while in some water <end>\n",
      "<start> a dog standing in shallow water on a red leash <end>\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATgAAAD8CAYAAADjcbh8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9Scx2WbbfCf3W7s45T/M2XxtN5s2b916Xm3LZDIpCSAxoBGJWgkEJasIAySPmeMyoxszwAAkGCJBQCQYFFEIqgYQEpmww2Ni3yZuZkRHxtW/zdKfZzWKwzvtl+vqGTWGnKnQVWwrF93ZPc56z117NvxFV5Yf1w/ph/bD+Ii73n/YL+GH9sH5YP6zf1vohwP2wflg/rL+w64cA98P6Yf2w/sKuHwLcD+uH9cP6C7t+CHA/rB/WD+sv7PohwP2wflg/rL+w67cW4ETkvy4i/0RE/lhE/vZv63l+WD+sH9YP67uW/DZwcCLigT8E/qvAr4C/C/y3VfUf/St/sh/WD+uH9cP6jvXbyuD+LeCPVfVnqroA/3Pg3/4tPdcP64f1w/ph/bkr/JYe90vgq9/4+lfAf+67fnkYkt5cbQBBUUARAAQRAZ7+U2T9OetvfFqi61/82SWIOBRFtSECT0mrIOiffQ6x7zdt9n1VEPmNx7LXYQ/yz2a/4hzamj3y+nf6Z17vr7Nme7/yT/3814//Tz+6PP3xP/VdXa+Vrr8i+md+/+mHIus/9Z95T5+uhep6ffTT6xSRT///c9en55T19eo//cM/+z39jfcqsv7IXpOIoL/xl7p+dtBAG/p0TT59XuvfyvoZ66+fSxBYX/vT+3q6zL/5fuTp6T89Xlsvz6/vORRU1tf+m9dOnx7S2ZXVBtKwvMGtT6i/8Xi/cS0+XbP1PT1dl9+8FT591vrpKZ/e16fXvr6utv59a+3TZ2aX6um+VqDhPGhTgo+Ic7Rmr9E5j/uN669NUS2fXm5TpVVdHx9UBVQQ97RnfvMFCaoN7zytFZoq2hrONbwDJ43WlCUr3gXGqVBRNkPCi+DCgPiwXgqllUatjVoKyHrFxK3XSnEOPt4fP6jqS/7M+m0FuH/hEpG/BfwtgP2u59/9b/7ncQ6QgjqH9x7RRvIBUU8Tj0Pw0hBRwH26F5oWWqs4EZxz6zW2W7Y1EMJ6860f+vr4znkaAB4fIk48PgRaayhqQQ5wIoh3rPcCwQlCtRupKeLWm1ns5vc03NPPFWorNHshlFKpRRFxxNjRWqOWGUQJoaOuz2EB0q3Xyq17q+HWf9uNyfo+BHF2MaRZIBAfqWqbq9ZKU8WLQ+sMFFptOO/R5nEuAIGmGdUKCrUWRFhfg72/EDy1VvsA1W72porH4Z2jiuAkEp2jYZ9TrRlVcM6DOmrL1LLgfcRJYBondA1ewQdsk2ZqbYTQrZ8N1DIiNPABFY9IACq6bm6R9XOvIOJxIVBqBRrOOVqFlAKoozR7by4IQYRaIDe7o3KeceJBPNQCmvECzkdKa7QCzgVKq9SaEVGEsAbodQNWT0o9tc14aZSlUqpDfAAHreZPAUIVVALalFoBF2hUmjaarEFEFVHFCfj1sxZV0IYdWY05LzgXEImk6NhvE95V5rww54lpXkAczTe0dUh29F3m6vqKeV4QlHkaSSHQ9T27/TW5Tqi/5/bmR5Tcczy/58P7d0QckBAGVBXvlNRFSm2IRKZ5ZplHrrc9dV5oOiHuxDTd01rl3ZuRhwdPP7zgF+9+zrHu2Ivns5uBV7c3hGdf8vnv/1UKDlGHU5hOJ7796itynnBByK2Rq0NpaFn4X/2H/9Ev/rw489sKcF8DP/6Nr3+0fu/TUtW/A/wdgM9eXmsMglKxXepwoqQouFaprdKap1ahOsV5R9OCroFIxG4CdY6G4kQ+nWzOO0QU7xKCswBo5wLiQZoSY8SvmUIMwlKqZQ/NgqTdUAUvinO2mWU9SFuzjdU+ZYcVtFFbRtWh2izAVbsRvfOk6BHxoBUvQkidPYcITgUnASfOTt819WitroHADvYoa4Buvz7layn23gGt7dN18q4SxNFyRltGnFqgrA3vHa1lmpZPj+Oc0JrinbPgKYKqt6Dg3NMHiHcenCANnNh1AY8oOFFaK/a+UFptFqCd4EKgNdvE4hQalGI/j6lnnBbAkWsmeEXF42OPlrxmX0+nt6DN3puqBRzvEk4SWh1dSJ+yisKMtkprxa6jvVWqg1YVQSyoOk+tFpztkFKkNXLJuNAh4qilUktGW0Gc0LQQYyAXxUkleCHFhqrDo1RpFFXmUuHpsMUOYxFPawuhE0pVllopSwaJqAuWmbVG8JGGZUKtVBxqWdZ6TzqfEPGUrOQyczjcEZwSohBjZZciXd8jodENcPVsR3N+3SMJ0YjXhDhHbYpoQvWaKWe+/vYtr1/8lNg1Xr++5nw4EUPk/ds7arb7L6VEa6CScNLRcuLD5cw0LlzGe1orhHDFN98+0hC+/Mkz/vRnbxjLhlgaV1c9n33xGd3NFUk8b3/xx7z80U8Q31Od4ntP6hwpJkpdmOYR5xNVBZz/zkD02wpwfxf4SyLyUyyw/beAf/e7f12pJdvNLxGq4GiUlhEE7ztcDagTlEyuGXGCeME7TwgBx1qC6VNmY2VLCAERu9lQRwjefscFqio+2GakNTtFc7aACSBij7um1uAQcbjwdOJWyypUEW20Vq1QWw9XxVLrpxs6+M42pb1CfPDoeoq3teQV5+zUFvvQ9On7op+CmVUd1TadeFqTTxu/tYq2YpmWKIq9RrduTETJWREJFpBLXssY22wW8Box+jVDaHixnLS1hvf2ulpreLEDxbKoRtWGk6evn/Jrb8FTG0qjVZDm0CafyuVcGrlYILdAt0EElmVCPcw5o1T2m44UA7WpvRcKrVZCDAjRMjYPKoLzkWb1KCJKiMGyMe/Q+lSSV7w2VOAyzyge76IFbO/sHmkF5xQfPLnZ4VtpqLPM0CMsJTOXQmsCTsk1Mx4L4BGEGAK5LITQg0bEB0opa7beEIVcZ/ARnCdER1kg+YjKgrqKDw7B0argfbRAJ0ophdKsDknrwTHNDVzH0hQplXqoxJBxLhOSx7kz4Ztv6YYNm2FDlzY48ZZZO2GaFoLbMc8ZpFnA9N9wPj7ipXA5jDgWrocd7tp/qipKdSwl8uHDiVoUbdEqFr3hfHgEX4hpw4tXz+gi/N5Pf8qHuyPLdMb5RuHEtQwc708cDifGwwO3r1+xffaaLkZub3ZMlzvmudjh45ZP++a71m8lwKlqEZH/HvC/BzzwP1bVf/jP+5va1H7VOdBKrYWmVg55L4g2QnB4D9FHVAUX7eV7bMNZKSU47z5lQLVYGSci4ISG2oZHEW/ZTnABF9YyEIghWPbBU6bmLLtUodFotSDNNo+6SmvNnlnbp4xB1hPaAlQkhIi4RK3tUymtPLV1LEuy/eMseAJOgOZQzZZlNQuUqoL3nujt/Tu3Zr3OUysWRNZSvTbrXbRWLbtVwfuAuPCp7/Lrno371DustaxZmbfWUM00GloteDkJNIFaMmDZZAqRki3LsizIrl2rghMLvIi1BcRFtFXEeYbe46VY4KprFq9C1/WAkucF5xzBdzgfwCk+WFbrseeoFXzYUkshJKjl8qm1gHhU19ZDXiw78wFtAloQhKHfU5q1NEJIdr1qBfWo95RWUKk0rdauqI2mhdoq0Tv6Tc9pnHFYX0vlqVJwTEXwfsu8VFpdUOdQjWtfz+5IYaAttg9UBCeO4D252PeWMuOw+z4vM4JdY+c9KSYaSlYlYxmvEPHrQejSgFur7qU0vBtodSFPhfNHxcsEeiHFQuoCKfVkHa3tUAXNga9/+Z48z+wGePniGXkSLmNhGmc2Q0+KkdPhRK7w4vkVDcfxlBENeK3428Dd5SMvv3yOsOXj25G3b34JqTCx0KYLlykx/vxXkCPilPHxHT7OaFt48fr3uFwqDx/PKAsxBErLJA9Lnr8zrvzWenCq+h8A/8H/j7+LNqjaKHXGC7RW1hRecDi8F5yzfphWPp0aqP669HHrxsY2vRfrV7RPpaZlfU5tvMCnGYJbA6xlH17d2ltbm7a4tRRdW/rq7ObRSmsL2ura77Ky8GlwUWtF9Sl9tycLIVhP5al57576MGu5okIIgVbt9EQyohBCxAKQ+3RdPjWUP72XhneBEJJlkNoI1qS0XkUrSFsHE05sE6pYdotla2hDWyP4p7Q/oGolrXPQqGsJ6izQhu6fyh4Re03JhzWTswOEZodJU8EFKwN56imhhAAeKz3b2rXWZj2mmHrLWNbenLg1Cxe3Dh7k16WaeDuAqKBKbYJPA+vIgtbWw7RWK8GxvpiIW/tpUEpeD4g1A9TKfpsYpxFxgZIbeKsIcA0vUKaZbZ8ARy5tfZ5GrTNehLqA4nFB8M6x5IaoHbh2rwZc8NZbKpXgHeoUCRHX7HMqa+wnriVzTORsvbpaFW2FXGdiCDhnpdzQdTZc80rsPFqUslivUETxMdL1A10a2HSOlBw313vG48mCaoiIu6LW59SSWcYL1RX2L694Hq9xqeP0eMfl/MCrz25oNXE4nPDBEVNBsyOgtAaff/kCOkWkcVzuYRM4L0pW4cXNC07Hytv3B66GDa9fPaPWBWojeqFKQ9KG06R0g0fV9tZymXD+OwZg/Kc4ZPjNJSJ4t2Zj3jZSzs1KzzULUoGmNrGK0TZPxXpC9v4aIa6zNxGcU9xaroboPpVW1qLyn/owlmHoOsSyv6+1WiahzlLgp4kqDdWCqCNrQciIWj9E1kwHrSgOxSEuMKQObeCDx63l8dOkU1WprVjZ6wXxCZGIE6gCoplKXYcAfr0W1pezp3t6vKcJsbMSqsJTsG61WYMfh2rAO7GMz61DOnVr094GAmghhM6yKxGE+BtT1YaoA2cTOW1KU0HE9rsNFCqINQwsiNe1TAQQvJP1cTJWK1p57Jw1753z5JLt+67a50Mj+EArE7Vk1oKfkDrculFLnhEsMHvBrsH62pZptHvHObwPpJAIwaZ0Ndv7rnVEmyM4TxcDS7X+WvSB5CAF2L/YMo4jTiKqHsWz2d6wzJl5nEjJkZeFF5sttVbykvFuyzRXlEhRIddmvU9nk8RuMyAIjw8HagNcIAVnfaZmn31TO7RDEJY8E7xjSAPzOK7tk8x+OzBOCzIF5rkyXAUqjVyVmgt4aHicelKKaBOut3tyVg7HC0cqgUKIjdNpxBWroM7zyHazo5bG8TixLA1xjcqRpu/wLtLKBe8r+6srWoPYJbouMOwC2haiD3z4sPBwWNjd7Hnz9i2PlzO/fPtIaz3Pdj0vb3/Cu2/eMy6Z83Ji/+I5QmS+FMZpYhc8Vy9u2X24opQjBUs8wnp4fdf6XgQ4VWBt5EqKsJZgsAY/76nrVFFxLKUSnPXXULXy0Nm0z60TUsumnjYZPMEkWlGaCOosk9N1YmlxzDbu06otf3p9rRag0komBAdaUCop2gTSMjCHaLNMTAIhdjYFCpb9lVatSf8bUA/nPN5b2abrFFPVSnIBgks4LzS1gGjByU5+S2CfoqVfM5Q1+KxZYghhnWI6xClehVIqrcITfECkrBNjq9FrqSiVVgvOZX59aHjArndrZZ1i2yS5YVmGw1sp6KplilrWv3GW9NDI1SaTSqPkav0usYGJiBKCW5Mnb/euWmnnxLI2WQMXLVsZXgsiNtxp1fpVNgkVch4RPMlHQtqAt+noPJ9s6qdYVhgcThsNqPOCS4F5ytQMGeV0LlQpOAnk8jTcUuq7I873CEofGrTM+fgRL5Xb22u6PtF05ny+EGOi1hnxnr73hNhRKmgrXG8Dy1xZysSyVJyLdClR1TLJXBbyMtlhXiBnhdpIzlHKQl4qu/2O66s9h8OJykJrC5WGj4mC4FJPFNj2QgzCLgVKztzc7ChLJi8zty+u2O06ojjG80QuSskNHwMxHDkezsR+YFqUaXHcPzwypETqEodjIy9WmtcyoVrY7B05Z46Hjvks/PyPvkGi8uFDxZfnPL+6wdWJX/7qwMNhojY76E/nmWc3e2qrdo8odN1A9D2imblmy3pFKDV/Z2z5XgQ4AWLw1n5bsU6fpog8NeD5VNaFEBFptLXPw1ouiXpqMbyOCEgQg0JQVxyNElykqZUpT5mtNpueIdb0rjlTWqOKIk3RWtcSwCa0yXfWx1qhIL/OQrwFWxGcrH0/XYMAFsys3PNAwzu3BhbBG0CI2goeG41bKBlQZnAFLzb1autVc+JsctzUek0qa1bUoCmCN2hCq6hmhEqpa89HAji/ltcLBmeyElhF8C5aWbAOpA1yY6dmLcXKKmfHgXfesse1gV+pqKzDDQ+tGFxDGzStOMu9iSniq6eqUos17YVmWeraT7XWqfUtqWrntnM4t0JQxPqIIUa0LADM80QIA0ggxo7gI94nmgbGeablC9oWK+F9Rwo9uda1nWGveZ4vOHW0YiVwqQoufcrMays2ARalqWWg4zKhbaC1hRiU87sTNzeOFDy77ZYQHDFAFUMM9L1jHCvH4xFtle1m4OX2OdOycL7MVC20eWaeFlq1jSwhUlXwkmhqWDLxiZod0/1CqY9oXXAukYJnsx04nCYuS+U4LoQmHCL03Yw+i/zoJ7dQC/kSOJ8rD3cfGUeP1MLV7opalcPjge31njQo1+t+8i5wPl3oOyXGxryMpLRj+2zLvEy0FinFc75kvN+y2RR8G9kNt3z75o7b2PGj3/1L4Dd89e2FN/fvaaI4aVxvr9C6kOeR87Kw2Q9QChqF/c0tH99fKFUs6dG1evqO9b0IcLXBw92MuAaukpLdtDElhu1AKcWSntrYbPZM04x4KwRFbLt4L+gKxRDpUVcNVlINitBUQDxLNbycNaet9BU1/Ng0z5S8oFSmDHNW6lLwDXwIxC6w2/UoQs6Fvgs8geOcqzgVGkKIiVwKmmfDe/mErtO0WoqVbYhlGitcwjnD2XlxRi9RtfG32CTSodCE1gxc6bz/NJxwYodAbYKPntIE2oz4SJOIc5UyTtbTEId4R3ACLuJ9BCKtTkhbg7R7mqDGFQuT12xyxZ/5yFOW6ETX91QsqLq1RFx7ebr2vnSF7Ljq0WrB3KYojqAB5/RTEHXO40JERWilrOeO9QGjD5S6WI9U3Bp8xaAUwSapPkRCCiCdXfvWmMuC1ozXSggObfFTVq7kTxVDXT9bt34E0nmcBPr1WpdWKVpwrlnV0DwpeKDgY880ZlJoPH92xeE8cf840mq1fpuCeOvB+iC4w4UQOnb752ibCM7x4f1by9DF4X3k1bOO4DzTnDlfhIdLYhqFouClUttIFaHVHpaGNk+TAUQ4z4XD+Y6Xz7Zc7a749s2JKpmxBU6HQi6Fm89fU5dCvQg/+8U949T4nZ/c8qNXL/hw98iffv2GjUQeTzPZQZCOEAspwdV1D25PzoVSlZId42Xh6mrgdD4hIuyGQHAVQXh7bHy4n9gMe37vy5cggf3rPyAn5d0//Hvs9xd6GRBxpHRm6Kx/a9CcBekau+trPn54z25zy7xMNoz8jarrz67vRYDzTuiGZOWWCtE7dtue83jm4/uPhBDo4gA4pjaRUlx7GJVlWejSwH63w8fAUia0JSu9nBKiZ54XylJXGEn9hJHzIiswVDjOk2Fq1CF4AoYPizGx215RS2HJE8fDguw6gveUXNfpqid1wTJRH5AGfUyfenFurbRKKYaF84ZnUmsq4p1HpRoWT8UgFLLi+dAVR1fWUjPhXWPJM6pC9D21CD5Y+diq9QSbgKPhyeS64IIQU484bxtNgr3ftawVSTbAWdH4SsV5a5qLi9DWMlYq63yAps1Gtmuu+dQKqLUYMFUx6IwYYySIoD5BsLK76IJIs+u9DgyoFSQS0oDltrOh4AVEC6VVCAlZD4On1VQNpuLBhbj2KS3brLVYu6GxDqoM3hJIKEoui03kJRBwuNQTnKPa9MEGIqq42kjqSE4ortKcoARas8dyVdjvEjVPPNwfaM7x/PkVTgLfvrmnEBECQ4DLeME5pZSJKg0nlYj11lorNFHmeaLMCy1PbLrIvve8fNFzuswGj+kiDw+Rj3cV5Ug3dOACY1HmpaIMOHY8nArbPvPTH2949/CRw6nQpRsmafyDf/ARV2eu9wPV7aiifP3+TBx2/OxXR8ayoXr4YnfN+fjIZa7kDD6MON+4XBrTuBBCh/cdqfMUMn0XiZoZAsQIb+8vfDhWZo3gHP+fr94wa+R3+he8/XghyZF9ELxWxnlic3OF+A2fvXpGFyMxRFQawxCIUVhqAWm04GjE74wt34sA54KyvVm4HCvzBCyOUQrbYaBPiRgDDw8nYtgQgqfUhSUbuHK/vSIX5e79HTfPb6jaqCVzfb0j+MLj4ZFlLuQMy5JpWilFGfoe5wovbm54PJypdFyWhuYzz2/21Lbw+sUr3r1/YJxnuuTpYuJ8uXC+XNj1glNdEe1KDBt8fGIVOMR5yprhiK4tUfdEHSqIt54ZCCqN2ipelVb51OvSWlfKTF5Btt4mi1XxNn/DUXEhUNtCcJ6iFaHigjFB0ELwSnPrMAC/It6tfyHq0BWILM5CSlsDn/fBekRVbVqnxdgAOEozLJ3Kb+APg0PxiIuUZfqUaX5ikIRAij1zVgqNUp+ml+sp3SohJZyPqPM4daTeU0pGNcOKARu6LaVkSs4WSJ315apa476WTIxCzXntsa4B0j9Nrr1lykGIMTEtM6XaZ+SDPe+n7FAEJ0JeFhY1HKEXh5fAE9HOeWPZiDjmecKpx7kttTWOhwm08fr5cx4PJy7TyJTt2jYtlDaz211RygwqXHIlxZ5cCi4kmmaev3xJWY7kqaI6o6VR5oXgG89vhd//6Z5GZMkF7xIf74+cz5nz+cLp5FC/4f7cuIwjNzdbnl9XxsvIoj3UyjIX3ry/Y7u/ouuEy/HCP/qHX7OURnaCRs/PvvqWbgho8+vk3H0aBG6vlNYCc24cDhObGrh/eGeA5LXfOheoLlLKwqYfWCQw5sw3b75iHC/stkeuN4k+dviUSJsNm/0XNM3cvNgwLmc2mxskeXznWY4ZcZB8R2nf9wAnjuv9NVf7Rq2F0+PCeJqZ5hmtjW7oiENHWeDd3R27XU/XJx6OZ46nhZILu21HzY1xWRgvC+hMDAURZbpccJJoubK7uubd+xOn88jz5xuOxwknEZFAqRkvRkRpWrm7f2QpjiqeIIHj4z2II3ZCSo6rXcc0L1RNjJeF3e4aH2FeG+fRObTYtNCvw44nYKxDV5Cvcem0WQAOIRoVTBtVC+IdqtaPFBcMCO0EJX4COdY6EaOn1IZzapPctTclar0r7wNgcBxRBVlpTGK4Mm2NpgsxdmgOawlsXEHnPTGltVXQEC8ECdTWaNVGDapthaYYWLbf7lYs2YwTo3/Zpqg4Z4OH1EW0+RX64um6gI+eikF7tDVyztSWERZqLSAdeamUdWIbfbReZxOcizgHIfRrIHM4w5ugvq7DNvcJMynOkRHE99bnUyX4X/dJvQjLPKGl4OpCEwfRArBoIzQ1aMcyE7sIooyjslwq0QfmYgG3LJmP5Wu2mw0/+vJHnPLC4XCkVSWFnmWc2O4STeF0sqpEEdRBK41putB3CS0zm1AJIXI6Nt69EaJX3r3/QOgan794wds3vyANPb//k8+5jCdCdNTRcZmUMUfG8cD5lJmXym5ohAitS1R2bIbE6XCB4qkt2ME2F6YSSb5nfJhXAP1MipG+33H/8NEGINlDGDiNjfeHiaIdtTWiDHhAZcE5pRu2+M4z9JFyqrT5wH5vWfF+uyE6wQXHXAub/RbRga+//iO+/MkrPA3xkRgDfR+YSrZ++nfPGL4fAW6eJu7ef+D62S39Zke372hF+fjujtP9gVzg+HjEuw1dl5iXyjSOCOlTaTLXyrfv39DUk4syzSMpOcZlZpodIURr6p9mfNfhxHM6NUZRKhUfG/M0E5zj3ceMOINvxLhhyTOHxwklIT5wPJ3ZdUZjur255v44set3LFnZRs/1vuM8LdRlYbcZaBWmUsl5YjP04ITpPBO9Ya7GZUbU8F5BAlobITloBpNpK6vBej4rVi/ElT2Rcaq2+XmC6sa1Wf9EHH/iShrcxXmoWvBPuDcU78tKjlbEexzFJqXOGzS6FSNn10itUNchSHJWYjfniD5Rs1ByXrMuRWsjxoaLNgBy4vHNU3WmaMSHHS45fJS1RC60+UJZTjRteGcTSprDS7SScjkhCCkZdKdhk2qRSIiDgZC1UfLMb/I1Ze0XeteBhJVhYUBwHyzzt+m7ZZQ5Z7Q1tjGwaLWMVT2UuoKIjd3QDx2bLjJNI5tNx3Q+U9URQ880TUDC+cDx3Fh+8R7xjaoT17db7h4yTXvm+xN9Fxi6LcuSjQLnApelcVkap7FB6HgcM1dbJXY9r3c9+JHjWShL43CeGfY7zueJP/qjt9SlgWt0vuC7xCLC7asrfmdzzek0crnAeJm5XD7ifaaWymZb+Ozz53gnHI8jm+0z3r574OF44jw2lsXjXU/NjVqsakjDwOQrVRyDi4xzI0+GAzSgtVCa4fly81weMzEsSFWoMy5VXNhyHgOxn2CCzS5x+PgndOmGx/cP3L7cEfcFpwOvXlwh70f00jNmRVr9ztjy/QhwS+X/8ff/iKubLS9fP+fFy+dcXQ18+aMB+XFiXhrHuyvm0RNi5Hy6X3FTBqaNzpOzDRUQoSrUXFmq0jThYzI0eG5UFnJdMXXOM5eFWivlsiC+p0nPotl6JalDbSfTBU9IgbkUfL/heJzZbj2PpzOp21pWIdlKPhx5rgTxaHEczhPjkmlNmS8XcI0UDQ1/uVzYbjqckzULG4kxoWAbWFk3YwNxNDG82xPLQ1SMMtVWWIZ4xIEjfuJUev9EXxtQFWoVRKpNoosSadQmK4jZeqLuE6BYqc0gGALMi/DxVIjR00fHXC9c7bdEcaSg4JXFFXIuCJ4WEqojaKbrI89fvOLj2we0Fq52e5aWDNRcL5R6Ji9nyBktM7VUYndDN1yRNSLiqa3SifGKkSfMoUFhrA+5UOoEIviglJw/8WpVhdhtqURD+rcJUePhirOyUasiLpBzAd8jwbFIQ1Ow6fcaMO2aK5uYoC0sYyaGjtgJfew4PsxMs2XJKVoGfblkWnXUuTHNC4f7Az/53Z/wzd3I+RDIXSD0E/vrgVImaIXrfYd3gfvDxNIckyYu50aSyovNe26vE4t4vvrW8/6horUyV0Fdh4odKpSZ0jJKoQ9v+IOfwOPhkXGKiD/z/Lbjcq58eHzkap84HO6RouSc6aIjhhPPrpXPX20IvuNyWWi1Mk4zpe6o5UJyldTBec481IyLgVk6CELVCuLJ1cp4cZWinsQLhhB5sd+Sywe0jcznxpwDlzLy4y8Sm93Cyxd7Prz5lusXN+ASIV6z2zTm8QNeMmn/PS9RvTMqzd2HE493J9798htub665vt1xdePZXHmev7ym5R0le7xsqHWmNiXGRPCOUgotKKUq0XmWajQZr0J0iriKdw0XlFIcNIcw2+jdBfymZ3GOeVloLUDrmaaFLhg9J+CodSJFTxAIfsNcPc5H5iWjrdINEfEddw8nCy6t8vBw5LxUxHdoE/oUUC0EJ3QpsttcEQN2qtcGzbPMmWGb6FJYeaZCa45lWWitkUvBx8R2t2UaL6g2kvfkUvGixARNHc2Ltb+0IgLBG1PCpcA8z0ZsLxOlKa15vPNsU0S1UNUZJqlW3BPxnoZLjSUslCwMaUeOyXpP55m2FGIUaAWtmWGzo6nHtwY6EoPn+Hhku9tRsjKPJ6apmQAAJ4Jb8KXRpQ2h23A8n4mxJ8SerttSi30WrRoH0TB/bmVdPEkWrSV68+T1cAIrnQ0wLSRvWWnJFVHD0NUqn8DJzjlSSlT1NFErs2MgSOJJfqnVZoDzWgAhNyhN0LnRe0/XQXOgztOnjiUvyNxsgOA8Pm0J0vF4OPD81uMkMc+etlTO9zM3u4R45fF84Wp/w5cvdkDizcdHxqI4F7hUz4vhClcrKcF4ORsAOkbGpbJMF6pWutiRuityaZR25us39/z4yy/4+LN7JHQs7yYuZ+H62Qu6pHzx2nO+fOBwcJwuF+ZJaTWyjIVaj+RmTJRu6Hn12YZ+eM3jxyMf3z3QMgQcnSjOLbTmcL6j4WmukWtFWw8u8vzqR/zO7/6YD3cjxw+Jq/5XvLraUEQ5nC58/fXIn/7yyG7Y0g+N+fDI5qaj2w2I6xnHwraP+PDdspbfiwAnotzc9ji5Yp4rp+nE4Zt73LePDBvPzU3H82cTz24XNtvEl5/3iNtzOhfOp0rJar0B56haUQpBxSgveIbO4fAGb4hrqZMrzntEkqXQ2vHhcWaIHUOXWMpI502lhBApVZH2RM/xHM4j0wJKZZsGVBT1wnk84bxjWTKbPqG1kVLPkm1DLsvCdpOoLOCMJ6pVTUZM/Sd+6KbfMC8zS14MHR4ju+2Ox8dHYogsy8x0cczTRHSmqmFjC6GWxrB1pNgxzzOigVongh+pxbHMjS50FrC0gTe4iGhDtOGlGWuLSF4WurShtUyulbyc+fxqy1h67sfCmCuXywkPRA9DHyy76yLiK6EV9r3nandNppBJ1BrY7zuutj3nUyY3x909ODIqiVIdU61snm/xrrPDgUbquvUarvSo4lZKlVuDjtKKWgnqBoL3LPmIkyeFFAwnqMsaCCzDETzRddAWQKmqCBGnBaGgruBU13vIAvqi80p38yu9TVd5o8RpWqgAUfAKKgXVhdvbiA8d37wfwQk5e3ZxR71cGDrwncPTswmw6ZT99ZbFHfn24yP7PvDiesdPfnzL+/sD9w8j47LhZ1/PlLnhqxBqJcbIdr/nNDaOKCqrGo+OlDxyczUwTQ8s7UhIC2l4xqwTrZyZ8sh46fmjPxw5jjvmpaB5JPWgLGz6Lc4Z+2FujofHyuPlRNUzwUVggx+g9zMvXg0oEw5lHivTXNhsOm5f3DBOSpFIFyN/9a9f8e5XPV+VC87dc/t8AG1cX1/zeM4czxO7feTFzYb7b+/Rpty8+jH5PBO9kEtjXL7nJaphRDNNG5ttz831K1SVeVk4HM+8eXPh8X7h/e7EZut5frvl2bMb+mHH7ZfP8G7g7v0d58tMEA8603uxE7UJPgSci1xGq/uDK6ToDCuFgVolw+ubLcNmg7ZCqaa2UXPDh455MQSDTUIrm01vAE88c6nW7ARK9XinTOPC/uqWh4dHpvFC6nq8tzIq1wpVuMwTCuw2PXmaSVHoAwzDlo/3F8ZpJERjOiy1Ms8nUEddjO1wuSwcjxeeXQ1sB2vgFw0sGbhMTDpSmiP6DZDQVnAk5nwmtwmn1m9LLrDb9hyOZ+ac8cFRXGBaMrHfcRiV+1Oj4ChzQD5MtnFCj7iBpkryFqTPk+AKpOi4CkICng891IVpOtNvPVkvuHImsefUZlI/cH19hWii6YXLtLBxibosNmzQRheGtZsccD5QayHEDSKN3BS0rJnqCr3xqzyVmriCD856PtKQkEzTLWcDCfvOdN68X0t9Z4T7IrgoRHVQjLfZkBXbCLUuDCFRm8li5VqpBVy0Xi15Ju4GHg9nlMSyTFz3K+bQRVyIPDzO+KY8e9Vxvdny9bcPvD8deX294+5h5LFUch04noWh92yue/6133vGH/7Rn3JcHLW6lfPc6LdbVJW780iu4GPPPI3U1kwHMFce70ZSSjzezyzzxGG+5zBh/dPF8+XLa5598QW8O+IOB8bzB1IXWJaRVjy313s+Pn7kNAcWIlV7rraBkkecd9zdHymlMs6V5JUUlC8/f0XqDcw9TZnT/Zlh07NNgfPdHV2Ev/Q7M3H/BeNpRNvEZy++5EfdliYLMToe3h8pY6XmhVbuKPnCPM0GoI/dd8eW34Ynw3/S9fK21//Gf/l3WFtAhlHz3iRuxLh453FhulTy3EgxEYOw3QRevbrly89f08VAf/UcdVvGy8w43rGMI/MqS6NqgNMY/HqiG8gXglHDXEAkIX6VPXI2APC+J/iepmlF/s9oPeNoxuF0wjI3TucJPIzzQur7lfDdKFlpLa1c1cb19UDfRS7nC36FH+CFkBLSKts+0tSRiymYdBFCcDQVlmyTSufVenDiqHmm93C7j6ZuUSpdt6dRCF7W114Nv9Qs+DqxwYKTQAhGCbp7/5YiGyo77u5P6/u/0MWENkdbucLlcgEJ4AO5Yqh674h+hby4gHrB4yjjI5sw8tMX0Sba3Yb7xwOo5/ZqQ+cLm17ZpgYEHtSxaE+eRvoUQDzjWJmnhRQiKUUqA5d5oTRBWiLXE6LySX+u1AXx0HTl7/pVw09MrNOHZhzjaj26rgvkuVCzwWsQKC3gvE0BnXcsc1kHNZWcR7puR66WvUe3QkO8x3lPmWfSSjUzNTjHOBYul4UQTBBiuixc5saSxfjBy8Rnnw9stoHcAr/4+i2b2LMdHMPNhq++Gbmb4fnVnufDQJITuJHClg/3J6pWHh4nwDPP2RrvGKRlmWdi3yFV6VK0Sb4Whs5RcuNhNkBw0EyXHJvthrh9yfs3D/g6sR8cu13HZR4RVXZd4ONhYiqK67cIQu8dwTm++vYNpTUDxTtHEiH4xq4XdpvAdpsIaeB8LqDKX/nrv0+/u0Gk4fNEDQ00mfCrCzQFp2fm1ghhQyiBucw4N7OcHvn49g2n0xkVx//wf/q//Y9V9d/8s7Hl+5HBiTOCt1RwBnAVGt4vwEIksLvpkRtTvshNWHIkSOR0VN5y4NnVhmn+wLA/EwV21zv8s+csrXH3cM94OUGrK58RTG/NgLQxRZseugUfIhTL+lpVq+/9iqFqhaDGJzUwbUWCmNJtU2J03Fx1eBx1MdhC9R3v7iZSCCimMnE8Xai1MqRE1w2mtVZNVPI8WVZV1K2KFAXG2ZgBLuAkGB2qrRi20rPUdWJ7HUkxMk2Vw1yYi9J11tSt2TLQFIVWM9M0UWRgiDCPDxY0fSb1Hhc3lHJBfMe4QIimf9fmQhc3SLTsTrWQgokO5mok/0ah1kz0gRA67qczL1piKwOPj5XWtjweFh6nQBeF7W7hKkXKeOD2xY5XV5EzhWWu1AohK7FTrm+uyXlGwoJI4jI3ur5nmke8M424aWlstzfkPBN9hKq45JmW/ElF2fQQJjpnOnplLoaSb6adZ1AYT+OCDx1CRwjRenGl2iBoORPjFiWCmpSTNmUpmbRqBzZVHg8HHJHgemqeWJbM1dUO7zPDkLjMM7ku9MkzzkprF26e3/D56xf8yR/+knIl/O7v3TD4xvv3I5uXA6FlmBvdcMtUCs9v4Ce/92P+yR++5c3bB4bdnvJ4ovfegllriLP7gmacUnGO42UkpYH9VU+YLkRdGMeRu8eFdvxALdA0kmviw4cL05zxztO5hSjWb4RMKzPVi03IfST5Qh+VTRfYpp6udzi38OVnL7i+viJ0V/zf/+4/RLRSNeNojI/vSbsNlIQPPeoHmjgb8Ikn+hUOJSPqCqqOYbvDpUDXdSzle062Rxw+blAxGZ8ggnerVNBKUHdObToYHInETdziNFEa5Nb45sM94pW+T7x6/ozJnxk2A13X8eqmh+uBaSqM00xu5dMUtaph5T7JpVd7Pe5JSHNVKoFiv5OLyeu4wK/9IRrXux5tE8YUzUgyOZyUHK+feWIQtDlyWahOcF2ktEzsEtRqvEc15kWTNZNYQbZhxbCZL8Fi4oTNYCNFQGuiaeH+UWlaCNExloLzkYfDhFbBBQvg52ndjItDpVBiYLd9zuPhDphx+kgi0McBRaid9Srn80IX4ypp1YjdgF+hNHVeUCdkrZQ6s+k8tIVWPbvNFX2/JXQVtyx479nuAt32ahVFmHicF8BTHhqH80ccDVS4ffmMZTqx3WxI3vH6xXMO44FpcXQ4tEwMvVCmyYC8Cdo8QmlkMfpbIBlTZmPCjLXOqF/hKEWQTwq/QlOH+AQoTk2ZOAg46po5uJV2NyMsODVqWBBHRXBBaAXuHw8sudBaMr5wm8BVXtzsubra8+3XM+PlQimOqo4snpmOx/uZu8N7Xn/2kt3VFfvbgePxyOvPbvnd331BlczxfuFwKFQmfvyTH/H+veNyOvHF6ytOjyfGXOlTok0zDuHm+gXnvCqXRM/SMudzxtHRFiUFY7I0CUi6JpXGqx0ca899SZzPH0m+kpLBl7QV+mGF4bSMRLEAPc3sYiD4js5b0nI/LvhF+Gw/cDlfSJ0jinBzu2M6XvjZP/pD/sbf/OtsnVJqQceJoieag93+BTX2NG+wItpkwgHeobmxTIVXz1/xbbnj8Xz+ztDy/QhwGBbpyUBCFIJPOGdSPcFFA7z6lU4jHc4Vkw5X0wfz22szt6iFx/MZnzq++fAt19uOTRpwEhm2O1693tMcoMI0zcw5M00zT2KX8kTlIhOjmiJDmfHSG05LjKSNi9RiFB4tFdWKWQpYX09WrTdxnpQUISPSTJFWZYUtGD1K0kohw1njGocPfqUYrSBfxLikqngxSfVWM7kVfN8IdJRg+mvFL2xdwyuwCbSiuCAUbagGptJWIHIlRMWFwm6/M7OcZlQyU9aw4K8tkaJNgVUrpVlDctNvWaZ5ZSFkYww4CHFgmiqlZTo6vv3mjv2VsSyGlNjvAufpnu7qFpqnZIf3ya5T9JynwnQRfvbVr9htEjfXwjx9xc3VANEzzYmlAa1xczPQh0DJF1ISTueJS1nIS2O4tmzO0aEZSptomiECPlBzIa5acC50sIo0II2aFQmmQ+YQpBaCD1Q1lkhr4OoTeBj6LrFk8xMRSfiQ8BLJuYIzXqmLibu7Iyk0nl1Hgg+cJ0WbsNkqX/74NR/f3jHnC7evtvzrf+0vsVw+8HieUOfI84lxvBCccnvbI+7I/nrLL37+ntP5iPeRes504knbLSH0ZNdzOlzILeNcY64FFxy7lBiiMC9nXr7aMnSRbz8cmEbAeVye2OrMkOD26sYob20x3rY25sV4wvt9Z2IVIaChYy5Kbkar67pIFxzqMindst+/5P7xQPAZnwqaI3//7/0x9TQyucrAjqvrDa9ff4mbL8Tte1oISP8MkYarmdoSLl3hXKDmEd8NuPg9VxNBK3U6mPKuDzSJNG8y5N6x6qA5IOBdoIthLevqOlSwQUX0hobvhsQ4ZzbDhqrCaa7UZeHd/YXr6y2SEpsh8OzK82zYME5CWZTLaKf8aZwppZgYoyjBW5PWVDhMXFPLYj4HYCVsMx8F9aucdxSEYGR2yaguoLIapKxS4N4axEHCqnKbaNKZ3tZKOzIxUFNvQE2puKgJkWttlolmKK4aylsCJWOabboKNvpVsUQbTQqbPlhJ4SKlLqbKoh7xHnViIF0WYhxoNRJTh3q3qsqCLx4Vx/b6ii4Wjqcj0SmX8Z7gTC256zpi9STnicMNixp05Lw4kJ55WpiWE33q2Oz3XMYP7DRxnmA8VabjhDTPMjX02YZ//T/7n2GeRu4+3tN3jo9ff0O/2TJXYeMT43RAm30+212HZqXMF4Z+S8knQkosZSYhHI4zPiaiNpPdSgPanNGlBKAQu0BRR1XzBdHm0NJWKJBnHmeqFFRMHkpK4/BwpBsCqe9xi6kwEzKqibw03r675+HDhWfXW26fBV6+iHzeB2qG3SawtCPPX/bksRA6TxdnSJBixLvIwxh4//5ElyrqKwOZGAZ+50d73rytHM8Xdrsd51PmcSrMdbZyW2FeJvJ0ok97+i7xe19umcYDPm5RCr6OPN9U3L4zJk70PO96Do+F0+nDqlRcCMGx225YpgP7Tni+Ue4OC1l7nHTsO+gCdB3kPAHCWCuuD3z8+C273RW57xmPE6exMebFsIwlcpEbCp/xOz/6a/y//t7/k5f7yu3tkeGqoS5Rlsywj9Q6ARHxjdurHWW6fGdo+V4EOBFHGm7ArSKGLn2SLJdWTME1RJ6UiUpZCE6I0aSPwCHBY10Uo2YJgehN+qcphG0HJXMZz4wPR/JyoHx5w4vXL+iHRNhErq4deM/tvHA+X7hcJrQ+9cJMux9ZydrNTjJ94kKGbhUWsZLOyUo3UlOsAFPoRyIVQ6mXmvE+kmulNCGEAQmRkieTYfcB7wyqUa0vSwie5qA0JfYJtyws84LzQrfZUmsg+AH1SiXTlsUk0Gr5JK3kGngXVm+LJ86qrswHA7KKWIYYU08/RB6P98g6iZRVDOQyPrKJHS+f7fh4f8fVpse7Si6Ffuips5D6nvN0RsQTQ8/pYeTm1S2NM+fTI2cZybLhMl1z/Ji5TCNZPOr21GVhu90S8xX/t7//p8TYkZfCZRpxuuXwPvPu/cKmi9QayHXE+4qnEFdpqXJ/hxMldp1xfGuhi0JixjmYFyPaOyfsNol5ztRcSb0n9QPjbH257W6P1oU6rTprecKFiPc7SoPj/T0pBPPpqCYJFdfDotRGKRWthW7oqSlyNy3MlxN/82/8lNJOtAynN2eGTeTlyxtyLlzOj4hrTMuIiPDuY6G5gasXW06HB/70qz/m3/g3/hp959gkz+UEm5TYPBuo58j7hws0Zz4jNELsQRxFC9++e4driZIXvAu0LEjacp4yl9kkmFqZqTnTxZ7gE1UqISjLlLne9ZyOD7x7WEA29AFcuzAE02W8v69cFug6R5cGfv7Lj2yTcD43lmlhzm2ViO8QiVxdv2B3+yMkXPMf/4P3zMvA4cMFfXvi1fWBly+u+PxHP+VyuaMtjQ/vj8z1yNDJCu/589e/VIATkZ8Dx3UHF1X9N0XkGfC/AH4X+Dnw76jq/T/3cVxA4n5FzrtV53/Vpk+D4YtkJUILq1KvQUDEG/lbViWMXI1S5EMwAKhUgjQcbZ2gwm7v0JootfInf/It5zGzGRJXNwOboWfoO26vdjy72SMu8OHdHfM8r+YnDpxJiLfWCKtMUVHLiGiyBjJFKZRaiF5WIrQ5KsVkwbAW0z6rzW4+QSl5ouWR1irz2n80ALABWcuqNCtAbhdaM9MYFVjqgooZzEhzaPX4uKVpYanBBAHEEjuh4fLFsudSDOOFUI3bhXOOrvMooxHxdcRjDWovJioAM7lmus01/dDRNKzS5s3A00m5nC+rZpxQspLSBmneFERCAp0Zxw9c7W+YWyWEwEYXgmb6m2vmSXi4O7K5uuZ0XxlzY67gmg0UYojMdWEuE0okqE2vF/HkWmh5QWvBXcBMZyrb2Og7R+qj9UXPE13nmaicLzPalN31FucF13e8fXjPJkFp2az7ULJimoAC5+XEZteZMGst5GzKw5Ww+loIw6631zVDEU8uG85T5P/yf/0Tfv93bxhS5uXLgf1+g6rn8eHEXJTjOHOeM+fjI8fjgT/4ySvm85Ef//gLXn3+E6alcXN1Tb+N6P3MZV5oDl5f3TKdTuQ8c7tpNPUMznCKMxuib8x14vJwZro0vDxNKCMyeOONAptuR0qB82kkz4A6DoeZ611HGK44LY5SPIPP/PW//CPGeeTnb+6Zs7DZ3IAWkneodBzHzMN5MXZJqag6ljqCm/jdz3/MH/zlZ1wuG/7P/6dHmj6A3lPxpAk254XH929pZMR3bK8HUl7QkhmX8Ttjy7+KDO6/pKoffuPrvw38H1X13xORv71+/d//5z+E4mgEbVDWKec6dlcx/bMnZV5Z6UMiajpQWonr+L1VxUdDnyO/Ia7YmqnqrilY8G4dFDhuemNLTOcz58PC5TDRgNTdsdn29MOG7WbH1XZD00JuyjQv5FzJzezgTM3VQKe1YmWf2sRN1JPnkVYqNRr/cZ5G0/3H40kUrA9T5ifTkmz+BhjIOIWE2fY5vCi1LdZL0orgEO+t/5gXcGV124o437NMldhFNputMTS0rnZ3nq7bkJeJYbeh5mYYOO9X7bLKMl8IPqAaib7He0eICTSxLIXN1UApC9O88Oz5a3LznM8X8vSA5pHWoOt7isJuv+P8eOB6s+E8n/EibDcD4zjBInx4eyQ6x9V+z939B/MVLRGXBkza0JOpqIP9sGG6TAy7HZfTgf2mRzWvgGkT3WzBANniIrhELgvRBRZt5Fnxs+JniBJwVeiqmD8tJlB5fjwS08K3bz8ydIn5fPo0gcxlYbvdoOI5PN6zHTrm2YYGQUzVAzyVjlzs3muijOeR03HB9Tvm2XO5jHzx+pbk9zyeHum3A0XhcJ559zhymU5Mi2Nc9FNPN/Ud0iZEKkrDhYFv3x04nEaKKNMyIc4zjr/idpMZ9vb8h/dKPjXG43uK33OukYc5sLQtU86QK90wUJfGXGZi6JHSWHaJ+e4MC0hrbDaRzdVrPhwejT/sAjjhool/+PN7KDNOElebRuhGxkthGiu3N9fcnQsfDhNNKxtTdMXFQG2ef/zH37Bwzem4QcMjXg882++Zzg+g8HCudPHReM9M+Gj6j+fLBV2Fcf+89dsoUf9t4L+4/vt/AvxH/IsCnGLKssadRp375BkgrVlWFIxobsrYltHpapRSaiYRTAN2lTD3YrAAv0I6/CrkWJ8Ch3OYpaKiZWKz86AdaEZdpKrndCm8v/uA446hDzy7veLm6pqr3S0lj9SmvP/waEDLWj/xGFut4BplLmirUDPBeXJZaNQVf2dYv9oyPmwAT0qeeS6mzebXIJMLYYW3OOfJWqmrj2ltlYCpKyAO1OAcIQTKk/VdMeUNM6jxlDoTMA5r9Y4QPaU0pnlCUbrUMc2FXM8oha3sQQviA6nrbGwfN1w9v+J0PtDqQs2ZGBxKgiXDEpBWaa1SFYo6libMpaFzJqSOZcoEieQc0Aab3Q13jweygylbYMpUmjyQNHB7+4rjcqALDl8KXgNtXPDNsF5OqzmcYZNJmxg5k6dXBe+s+e28iTOu098gjeDgMjU673HayIu1I5ayoOrRFjkfMy4URJrZ+p0vqArbwbxE5+aoJaAxEoYb7h9P5rEggeUyEb0H2bC/uWIqwFi43m7Z9AOXaeaShX/ypydKLpxOE1UEHzujnM1m5xf73p6j9nz9qxM4xzjPPB4L47JQVblcZpal0qeOrt5x82xPFyJnrfz8wz34gUkvtNhxmKBpwvkOJNOKkJsjy0CRZBjUnBizlf1JKqfHkSKNQsAVTyeOfW+973GeEddRa2Pb9ThNjGVh489cbxaOjye8DwRpZhbdbzkcJ3Keadr4+S/+hMYNrU5EnWjZJJGmecF74fEi7PoA2jhfRu7v73n92fUnd7k/b/3LBjgF/kMxq/n/0Wrm/FpVv11//gZ4/S9+GLHpo4hJ9yhQV8chE0JDmxK7uJaxBtxQlODMSZ5mKqxh1VIzMrkSfDQ5HnlyvbfAFpON+EstqxMWq6RPwGkhSiUk2HY9uQjny8hXX33Lz9sbrq/23Oy33FxvuX0+UPLCMPRMl4l5XNimwHE6U5rio6HutWRkfT9df83ULJD1vUeJqDiTO4qenJfVJSpZkNJK1YnW1iyR1QUdY0WoZtSbErAP0UpUB9oaqYsGRA3mifCpl+jBqTDORuKvRLw3RWLDInp8iOTS8NFc1fPar4peGKcTXUpsUseZE+8+vuf6+We8evGKb0umhQhTpSBs91dMOeM6MxueZuF0Kmy3HdVvOY9naiwMVzds+p6lXSiu0XWmZhsq1LYAppLggie5nrktRsuTZNZxUqmYA5qqSZ2LMyEC74yFUEsGNUd0Uy828HfLC0Of6JOnruYz7+/vCPGGpQqNBVcW86u4FHLOq25dIfWRfthSnXAumU2/ZXN9xTQuLKWyTM2kux1AZp4y8xRAIud5WUWbPUuDMTu0mlYh40TwgRQi6iDGgW/vMpTCkDzjeKDWgPgtU4HLZbQeLYVSZrau45s/vXC4LJTsGHbXLNXjSuFyudDmSt9vSME0GWttJA/XsaO2TBVF9UxuJ5OuUqVQwAeS9JTamF1BW2HfzK7R+ch0mLg4wYWOWRvPU+Wv/e6WPB8YRUk+4VzPKQszmBZijSzLRHMf2G5uuDxkPt49klKktcJM4UKyyq2YcMZwdUVtjT799rio/wVV/VpEXgH/BxH5x7/5Q1XVNfj9syFN5G8Bfwtgv+1pVWhu7Ws8laJr0HESUDXtJ3Mkcoi3jSZqgc15Mw+omN2gAslFQujWnpKsxGhrps9TXh2njEguq/NUawFqwYv5gAYxC7f+xtPEfEfPp4Wv3ip//IsH+qB4D6nvSB6uNp6Xz3bc7nskRBDHNJ4J0shlQnGUEhljz1yg1GKKu05WT9H2SVX3yVGrzCvPNJm8e1VvcubNspZChZKpUiha0NbwqUcpKwDTpp4qRr7PZaQWJUqHCxtK9bx6fc3j/QdyrfTDNdMyUtqM1hkBbq52nMcLw9ARUwI858sM1XH9/HPO795wGTPn8x3DcMW0FCSPjOOF83hPP2zBBa6ubhnPI6+/2HL/+JHY91wFI61HKuN4Zrd7RqmzTSFroyyVt2/fsNlfk5eJ1Bts5XQ6EUPPOJnwQlvR+8CqRWbWirkueImrdSPE4CjV/GxrA3NXDYy5MelCLY55VmL/Akk98+VEXiZT3fXJDhff0RCW1qgLFFFC6Hj97JoPH+8Zp8w8Z45jZilKjIFpnGlacMETdh1X17e8v/tgFmp5YcrKXD0pBCiFLiqxVYJa2b1cFkoVou948XxH3yU+fnhEnOdymTgeZ7vPW6HbD7TQc3/3gO+36FxoSzUcZincbgb20dGFyIvPNpynAzmbVHwXPHkaKcUMa5alR5ohGgqVthoclUWN51wglEYAlnakuQUpFZmFZ4OQpOcf//E7DseZzm1oLXJ/yrjhluGqQ3IBXajNHOfK9MB+AMpMXs7E2PHq5XO2m0jfBy6nCR1nrq4TfXKc7u++M0D9SwU4Vf16/f87Efn3gX8LeCsin6vqtyLyOfDuO/727wB/B+CzlzcaoxnhPhnNqBrp2TtvDWvxqwHK0/fcam2nuBhs4io2sFDM8d7HBKuH6DSfoU20KlQqwUeGtMW5RtO8GqGsgoeSyKuRS1FZ9cEErwqqbHYDnes5Ho9IHk2UcZ44t8abd4U//OUbbp7vuNoN5OnCrvdcdYGbXcewiSy5Uhg4nBvHUTkcrcxj9VF1zuAdrUVUHX3qUa2WtdbV0MY7mixWatZseEBv0ufOg9bZWBAoIp2d6pgAplYFH5gFXPQ4Ih/ujuTFxCKXYg7rKfVoOONxTHnGxcjj8cBSIjHd0OitlNNAv3vO4XDBCQzRs9nv6NKWvr9wODyy324Y55Hj4UApmSVjODTfk+KWzW7AS+WyWH/r48e3qAqlKMEFclW6bmBZJsY8EcwXkMs0stlumJcFFYcTg9W01hiLlfalFjSAqBl6lzKBKKnrkGZwmqrCuQrUhtOKhICLkcsyscwTtZiVZNdFU8hw5q2gzDRxXKaZ8XLm4ZA4nTJT8UhIVE2UNlHKxGUq5DlBEFQzh/EDAjjXCC7TWOjiQNTGyxfXeMnsh56aZ7QWlpLxXqjN8+brO1L0XO+f8/XXbxniQBaTCaulUDkzO4MhOc00VwlDT6oer57N1Zb7w4Wila/fnMiYInLAvCvQylIqlYmlFDoX8JqJndLvIvswcF4WJk1sb3Y823ie7TwpOOYpczycmJaFgoJ2vL/34DYImXmeIQRqOxNCw2/MujOt/hktn+m3Soyerh+4u3tknu+peSa6Gza9sN8JS7mgtWP+bQheisgWcKp6XP/9XwP+B8D/BvjvAP/e+v//9b/40VY7vPXEfTLdDU6IIZlX6grARIvJ8bSKeBMdbJicd1i9SZ0zcxJjGpgmPzoiUvE+EEMihu6Tym0Q63d9cq4XQSV9krpWhLlYGV3VHrXlE8nNSAcxWLmM96Q+4hDqknn/bkLV8+HjTJLGdpPYbAObXeJq6xiGLanf8+J55O7+nofjSM6gYqVpwwCiNZsDfCsmA+5dRLUiPqGrd6ZopaAmt90qKgrF3MRS19O0GeYuRJoGurTj7nRiOX8kxR3769fMdUaiTYd9cAZfIJm2nA4mxxQGliniQ+A0Tux3V7x9f0faDty8fM3lNPHx/p6rq8Zf/oN/jV/+4itD9Yvy+tVLvvn6DSl0lKXw7PoV03Jm2Dr2V1tS2nH+5a+Yp5ntbkurWxpivgXThWG74TyP5FzYba7I9YioY15M3qm1gmvVMnrxSDAT6BRX/1h50iMzWEipZhS0aDFlGdaDrC04X2nLmWVZmMq0KkJ0nGYb2mz7PcucOR4m47ficX7L/SkzLx1TFspUaGWk5HnFHQaaa8agQGAyi8RaDFw9ZaXrTEn4zbsPCJVNF6Bl+m5jSsfTiVyNn50C3JTCze0GHyM3N8+ZxpnD/QNRGqmP7F3Hbrvlej/QDeBVOBxGfL/n1fUtLJngIqdlYVxM2abVwnmemWpjLkp9ci5zAe8d8wly7NjdvKIsF3AVHxNv3n8k+mYc7Lrw4vVrXAhcDheWRTlNlbFkhs6bjZJ48KZP6EVATyuVslDKAnWi5AueyiYK222ki9UEQQFpnvN5Zs7pX32Aw3pr//6acQXgf6aq/zsR+bvA/1JE/rvAL4B/51/4SLoGiJX59NQv80HQNptEEav5rehK4wq4YKh/1KAJiBm8oKuTOw5qobRlzf6CQU18MEArhdaa4emamKvXKjkUvQ0LlpKtd6POTGaaoj7QGgRJiDOqT1uNpP3qRSgofYyI62nVyMe5Vt4/ZuRQudo11B25ut6x6YXN0HG92xFTxzfvTivfdqG2BsF6dM4NNDUbviBufU4zWW7i6FIwr8+qQCD4HqkLSyuIj5QGpZi/guQCbSKZ7zgfPn5L7HYEDQiB1hytbcnV1G932z2nwz2hBUpZOH58t3IcB7yPeN8xXi589tlLWq1MZ+V4PLLZbZgmJZcTX/7op4hP/OxP/pgvPvuCy2Wi73aM04mmJ/oBbl++4O7jR16++Iw3b39F30dynuk7OD5+wCH0qWd/c8vhdDE7wLasfcmZEAx/iDchgeg9rRSamEmJiuBcZ4dUNRPppoJUxTsbaimYg1nJlFI+meaABc1pLoyXe7xEikTmbM5otS1UsQxdFNqyrPeCJyTHNGWaCil1VBVGFaQIWjJtziQfmC4zk5gRzqbrmSbB+S3u0uhkQdLAqBtUMm1RPrxZoGWyVsSZcISwQ6tSTiul7hQpv7wjhQmqoiQkHPEa6Z3ipFCd0m13JB8RVfa7jtuuw/vEw8cHNinQ9Y7TeaRJx3mpoDOhzHROyacLfai4ZPpv1+nG/EpbJUTHkBKvXg5UdZwuI3fHidNYqbIwFxAyUZQUQHWmd9mEXXGEYUsumculEaOjNhPBLaWRhhueb/ffGVr+/w5wqvoz4G/+Od//CPxX/hM9mKzofxcQt95I3tQ3cNCoiDYc1hRWDPdlPqWmNGt+B4365ImqYq5O6zgieMsEG8WwYs4sQ3wKVAWcp2E4OdQxzxnEMRdT6C3Z6E0uOvAJ1xTNFnzFeTNU1kpbvaB8CPYanPUHm1OkCX0/gHrOGZap8f7dPSk4vvziht2gxDDxxed7cm0cHoSPx4pKQJsBhp04E1IU47Z+cp53QhWhOnDNOKzqvHm7OkGzItmYEcEHyjITHUQnLGUiRsjMnMaPRN8BntY8N9fPOZ8v3D3OpDSwlALecXu9Q1WYxxPD5orlMnF9c80yzzx/9pz7+xO/+Opr/vJf/iuodqT0nD/646+IKXB9+4LH44H9bg/eswkb7j7e08qBn/7eT5jPJ5bzyKtn1zwe7tltt8QuMl0upNCTui13Hz6iWigls9n0jKNNFYs2YuxREUpzFr7FPHAtmFVqMwtCxbxug/c4L2tpa+YzrfoVe2iZHphlYlGx9sXajy3qUOcpBaqaGog6h9ayBkVHrkrLBR8SNKgE8wANaR2GFJPmqtYPDiGQQofWE7fPt6Q+oIvyxYsbKpWffTNRdMMsSk0LlIZWg0+BsjTB9ztyy9bADyBhx3kRcAYor+UMCnPaolksYxozXhaTzKPR9EgQJYpwwZy/ujQwliOlBUQdfYwgy2rMDtOihBiZpmYKL6sidJ0vuHiBXAmrQvSz3YbN1Yau6wxFUWaomCQXymazwXUBCQ5tmdiZgve2iwzJBkunuTAuh+8MLd8LJgOYe/3qk4x6oTm3uiDBemuiYr0Sc7E3SZ7WsvE6V6Dqk9myqqDiMBFJUw1eLV8+3QgiblWgLuYnpx1VzeijqafkQqumFhK7RGnFqFaqeJfwKbDMF1pbPpXMiGmJmW/n6khPXSEr7Ul3ljh0bJLjansNwOlyYJwEefSM4yNC5eWr52g1GSYzqVnd23FkFZxPK5MDQKlFrYSWQIhCk4ZmLNvsoAXTU+v7PXOeKbmnNqVLjeoyqWa6KMzliE89gx8o03u6AFlNEbnbbllq43Q+sus3ljUuC/1my5IzFBMm+PzHz/n40fP+44GXL25pWnjWhMfDI32/45gX7h4/8tf/5t9gHgvTaWYYPKfLRBj2vH9/xxefv+J0OfAHf/AHvP/4ltwm9vstZVG2/cDp+IHWGlf7V5wPj6b4gYIG+tTZgGE60dS8FQTFrx4U4oTo/HpHGFUNNZ8ymqzHoh0k3ptceW5CrkqIgymRrMrCajw7VI06WN1qUN11tJLpertfG+DKkwtaRctEcBiPMyaeTIlETO4oyJZGQFrAu8o5K5u+8Fd/PHBZlJ+/PXFZoGili5FWLjjn2Gz2LOKQKSNSaNURQo/4PS4EtDS2sTfYUcncvt4ynUdOpxMhdIS+Z5orTYXBC225kAaPSmRRWZ3UTIj1zWFGW+Gqi2z6QGkFP0+8uL0huMuqTC3c3DwnDR3HhxMffvUrHs9mFj1/XNhsG9f7Ha3Au7cf2G+2aKncv3tP1Yr3iqjY5DoE+s3A7ctn5pl8PuP+OYpv34sA92TP5r1BOMQXnJT1hgNjNayZGrL6iQqI5wkeF11HzgveNQPYOl2HCWbDIk7RZgR94w/W9UYSUE+tlrF5l8hrjR+crJi6Qqmj0ZyCQ6TS6kRZsumPPT1OM7WTtjpFtXUwICJIaZ9KJONxFZTK43FCMXUQ1cC4ZM7nytWm5/6QscGf3WxCwotJpj8Zuui6FY1rKpadtUATY0B0mx1aMkEmOoQ5C+M0g0u4KAiOLIq2DW0Vcby9veJ4uVAlcH1zxWWaaJeFWsxq8PbqmfkLFGgEcJHzpZA2gZevnjOOM+/eHfjx7/yYX331DW/fCs9f3FJ0AR+5vb2FEHn77Tv++A9/wbNntzQX+PbuxHXxXN3c8tNnL/n2l99w8/wLDqeKyJZlPqwNZcfpaDpgMSXzPnAeLYXkBaSYKUo1UDOiNG8QIqdm5LP2RdaWgthAxq0NipUpQquGwRT7fdFKEseyHC37w8QLan26iRu1TNRqYVO1GSIAtxr6mOl0Eyt7iY7gKq0+tVQgpIA0G6QtBcbFmdpwyYyPj9xk2KcjL/Ybktvw7d0F121YlkYrA602VBqRjNtYFbTbJB4PprZzdbXlxX4PueL8lsM42X2QC7uXHf1m4M3bOxuy1MBcK6mPFFF2e1OtOZ0upD7SKPTiiSScWma6320peeLjwwObrfLxsJDnE3/lD55z/ewF//gPf84yLSwlkksmtwsZ5cOHB2p1xLSDUugFrm4HY96Qaeo4HoXghU0vlPFggHEXQL/vZHt5SoktcIla6eBWt3GwLdzaaofn/HqTgmJT01IbLkQTsqSitVn/TTDxRCz41NpoZT2dteBE8d7RdyaIWMuZlBythlVGx4CyOFk13Qql2jTWrcRsMIS/acphkJZmiiGCrFi2BqsGXfSBWs1LEgyeEh3gKrEPXF91uGqT4eQCTSCv8AcVMUmn1ta+oqnJ1rpumqJruTCg4hgvZ/pgOntKJIRAzg3vbFMHN9AkUiVws79imc9cThPCQG7CN++PxBjwsqG1QG6Rh8OFzbBl9+yWyyppfvfhkZIz4/nA8+cvWZbM6XxgEz1BMikU9l++5k/+aGK72XE6Hbm9vWW63LHpOh70zPX1NdpOlNyx2w6k5Lm96bm5ueHrb74lTD3naaKVyo+++IK7O8+SZy7jvHqyCs15w8G1BW1mLShO1wwrWtmoHsWknpzzlNU9TNYgY2Kgfg1i9re55JULXYleKBXDZyqIPHk8FETMAMU7z7JUcq70/RYXO3KebBDiO5oL5NqoriEyEygModGFmV0fGVJPLoHLZeZqZwZAOW/ow8Rm2HD38Ei32fDqOVymkW6Vuq8tMs0FFQgOXAigI7fXkcs08vjwgflyJDnPUu4o6lmyrgKiQv1woDYhpsSsdnBMTZAGlw+zHeQSV2hVJSVHmS+4tKFI4cP9QssVJVBqYpnM+vPxAX7xyz/h3YcLLgx0/ZZcL4yXC04V3zwNYc4XWg9ugBTMMCqkG3717T2Hc+X6asPGJ3wSurSl1WruYd+xvhcBzoKNiUGKsNKSTMQQWClKwVRy3fo7/HoyFkKklGoQCGe8R/FuRY/bTSbOmXXdqtAhWHAJMRCSqVD41Ul+mmbLxrw3EHADxLMsE8oC/sn9QOmicWERWXmagsliu9UDQKFW48yqAo4yNwuL4m0D6oR3Di9W2kJBpODCwKKembaao4Dq6p7l2ppBgIojpGhZSLOfeW+igKfjgqm7GoC37zw3z/Z8/Pge1RHvhJR60mZProU5nxFXiS6B9Gy311zGo6nBNnOEN5Pkwjgf+Mnv/R7ffP2O3//pjzgcH1ARfvXNV7x8+ZJv37xlOV+43vdo3bIdPJ9/fk0tB376e6/55S++RbTxcPhTXr78jLdvT2yGDZt+QMi8eLHncLqjPmSQbNzYVVL8eD5SmhJCIkaYiqC+R4mrO9YJdW5VHLbJnnPRsJKqOOnMx4GVGgifBjaCozZTvvUu2LCKiOYZH2wgYc6qHqjUZnCMzXZDziDZgwq+KrgOfM+inqwdPvTkJjQf8V1HLRXfRrrUuBoqnz/fcf/xW6pmas02aPOe7Bq5grRA9TvSJuLiRHIzXehMHVgCtcEwOC6Xy4qJW13YxNN1CfWBpfl1EissRamacLE3Tw2vTJdHBKhLRtXRhYRWY9D4ZIo7IVlwz4uismGc4Wq3JWw9Sz7w2cs9u8FBHpiXLfd3D0iAz798RlVvnied4fBKPhK7nu1mx7xkawOFnqUK07hQ68J+uGI/3OLERDuzNto0k1LE9/13xpbvRYCzY9CalE5sYtrURvqwZimrUa84XR2V7JQsJvVhzf3Vfaqp9Uqy94gXPObA3mYAgwZos2ZoXRQp2Ai/Krld7OYUR2nmlVmrCVE671ECrTorI1DUWXlYVK3nh/sNvJ5NeFXFyhCxgYQ6wcQrbXAQfCGKM4nxkMAFltys5/fksA5WCjtWSItpkT31I9vKVcStptLtwOVwIsUNDssGXfAcT0cOpwe8d/jYAYG8nLnMZ3tdVFI0CI0qeF/Zbzuj0LXKUgsxQMmPeLfl21/9jOPjGZlHcJ79zXPmPLPfdFx2O2YHKUGrM2+//jnDsKM4R55HtkPH4F/z/v1XOHeH9zN5jtQ8cMojtzfPODw69psbggpdgPuP78ykWXrQbNCX6HFkAtUsCMVER33YIMEDZ+Lad0XcJzVnbcXAwSsGUli5lablgsM+C1SQ1ghxY6Ds3pEU5mkhSkSXRoo949muoarxosUFko+fDtWQLKii1bIfbxQ/xFOr43hR5uURiPjquNq/YjwfOGWPtsIXX+wYDw9UMY/Twe1IcSKFCueFqSi1NWqp9EEIfWSeC7koVT3zouAHSoW6CLWarFXorLc2q2NZRhBP54RN6MAp2yEyXTLSR5oXmnoeL4VSPcEnWp3oPIynM63C7iaw3Xjy+QMBh+YIkri58YQwcz6eefnMOL+Ph8rx0tGkx6eOwW0YFzUsa3B0fqDrB26evwQC58cHLtPMvFQ23jOdLqThuz0ZvhcBzlJ/tdH9msE479abUeym4ckR3gyXxRkwEYWyZJpUvPMEcbBKKy04nJpPqor1RIyEbtmWCmQVU93QhLZMKRHnPDF0LMuFhhCilR2tqeH0VGyTiAUOmpoWW+gNYrDi9bwouEDD+kPGzLD3mYKj1WLZZHOGbneK6ozi8f3WOHqr+5dnNWUW82gAR61K1gZSV6aG8VUddsrGbs80qamMAK5C6q5Y8kTVhkiHxMQ2dZzOR5Y80/d7vJp1oHOF4D0ikS5EWs1UERrGAqEtlMWx6QQvEzTH8eE9r1684v7hI1f7gSUJS77w8eFbXj3/jMPhAy9ffcbDw4Gr7Z6HZWa/eUapI0NXKUtmPAvPXn4O0nj56hUP9wf2uw24QqUQg6PWhaurHYfjA3M+o+2Ea5kQDFtF9ThpNGaSyOrbIGtfbC1F5Yk1YtaMqg7BGz5rJeo78bRqHrWqMF8Waq7EFOmGnstpJg3mNNVvEuPlDGqVRgymWFNaxrmO4CKlNWJKLC1T8oxr1QAooSN6R+ocNTdCMFn23Bwte7oQeHm95c3DR/KSeRwLx4uQoiMGaLWnNmMeiI54V2i5IZIInSfKBueU8zTZphdoQVjyiTo2fLdDpGOa7bO9qMGqtDU8HtcnhuTZDAN3hzObrsf7RPSFPm642nXkaeZwLHgHy9wY0i1dqvTquZR7qgscH2em84UPHy9c7W9xsWOz39LE0RY4nI9cMuTmGPod0zgT+y1VIlXh6sUVy/v3qHN0oYJ6+t33PMAp0NS4gaxlYjNJRyx/EysTeQJrhpXKZachq4SPNgHnV5MZIXq39sUc0Naey1NvDYN4SIf3kaamkuvooFXm6bKWwG7VSKtmELz2bRBPWaF7MUTbDL4jN3v14qJNa9V6NsH3KxeykrwQRGlOqdqMhuWUog2IaM1M5Y4qnhiMeD83wa8Xq+mTcTX03izznCTUQ9fvyKpcpmzuWziG7cCyjGuvUolppa/JnmkaKeWMykJMFmjnpZFCAirOO4Lv2G0j41TYbF5wPNyjdUFdJrjB9OEctFr5yY8/4+7hiFML4tNoNn5f/OQ57779hlyEd++E7e6K4/GRfgiczwtVF0ouONcjLvLmzVtCdNw+ewVeOF2snA5pQ22ZXAt1OpnCcCkrVtLTWo9zA84Ly3JCRRibDZuiN0B5ZD1Inaxk+mYTWHlqNXi8s0rA+SdFZZjG8RNAGGy6PmwDQ3/F4XyhlkLXd+Z0pUpZvXljTDbYWtWaRYQQO1Ns1kYXAqoz3vdsNxvGRTgcJ3xwpLBHKKRO+PbtI/sXr3h4OLDtEj7YYG6arOcVu4CTRujiKkEYyIsdUqrFPEPCnqqex/MZVxu1+NXHYwRZrJLqBivnXaQ05bE02qik40KSRyQa+yLPZpY+LpnHu0dzN/M97VI4XxZ2nTAk5Xg8MBfPm48TrRTmPJlZen5BaEqfK87PaDmx30PXAtOcOR0euNrsmM4HWoV+0/N4+MB21xOGitOFlDpi8nzX+l4EOLBSS1knjmZJZNNGq/f4tSLKmolhE72qde1zySepH+9N5depMwJ2y7gVp6PNUTFDDvVqE5gV/0Qz3JqI0EpdA5kz/qBX4wg2T1XzwFxnlzTcWjpma8Ki5i/hDX/WasU6ZwHnTczzqXx1fp3qOXkCsayu9daHE1UTUXSmHIuDLnaGLSoNmtpJGraE2HGYprXHpKhkQoyWTUQ7BKKPTPMZ54VcLzZcKY55MUaG08Yw9IQAnd+CdnjvOBwOiHfQGsP2GVQTflzmSqkLGnt8DPy//9E/4Gp/y9Xuhloar15+xvv37zncX1iWmfN4oVI5HR94/uwF43ji2fPnnM6PeB+5v7ugCtvthlIzd3cfoDa63kyrKTYYqiWz1Illno3NIQ4XEqU9yZ56JBhRO3bJjkxpa6YG3psxTAUb/oRmm3vlbRvG0iqH2oyILj4greCJ5NxYloqTwGU8sCwj8zybXwYGHkZWCIiYK5lPPbVWWl7sYPOO6Ho6Fq6uEvMy83hcQBdeXW/ZDMpucISgOJ8YL5mSM1+82nG7v+VwOoMoh4sn10ReJqQt5r+RTCQisNLXyMRuC3lHRbjkM1o8TgotV1IQqjiceOYmhi1qmT527K+vkDZwfPiIF5NOd20hekcpl1UbLxoA3ytUyLVxmuAywzInJFqrplRFa2QpSlvORF+Y8gRtxjOSnMeHnlaVCRA34mTg4/RIGBfmseLuHrnZCsPG0dfKoN/zIQNgtJoGpTXjl4qzoYE2xFl5AZgyhDfgX1l7GZbBRNBKo+BWpd2WG6w9MqcYXMCZjLg4bNq4ktOtv2UZZFNTRXAr4b81sxh0MSHElYOoqK4N6WrAYeeMyyge1Bvk19RBrBne8NSS8SvQ2AdvU78V/5RrAw/qZBXHVBt2OEFF8ZiZda3mg5BSpOSCohSdGVLP1iWmecWjOQvqXgyzt9tuuZxnrnZ75vlI8gvaHKSe18+fU/NEbhUfbeOmTnE+UOqG3f4l58uR+fKRzWZHcZ5aEsN2YBxHcmscH0e22y2Ckafxjvvjt7x4/Zzj4wP/X+b+JFa3dUvTg57xVXPOv1jV3vvsU90ibhU3HBGpxEYmoYWEaIAspdyxoENlkR0sOjQwdEByxw0KIVmylEiWyQYYerawJSRMGgOZieXMjMzIqG7c6tRnV6v8/38WXzFojLn2ubbjRAThTOnMo62z99prr+qf8/vGN8b7Pq/4QN8Fgiykbc/QK2e7C+5ub8jzgVNdGIaBFHqqKvP8QL/bUo6ZaTwx7DucTtR5BhFKtaO2cx0h7KwS5UieD4gEfIoEV2jVr3a/9d5a9ZLFRqG/solaJS1U46/JKh9SE+xWrWulbw8rYvdsqzNdF3DekXOBZmE3sk5ZcYHSGq1mXF5wrRJjwqeIE+HJbsPD3Svy0thtI892Pb0Hv2mElNe8iS1lMRhFbfDm4YFSG9N0YimerIah3/cdMRqQk9pw4pmmEeeVoI3xdMucM+KVEIQuJaJ45jFTfCRnZRvs+fBaCZK5v/4lmz5ykSrH+cR2EARLKvMhQhZEq3lYxcIS67SgfWKqVijM2QZXIXhaC0RRXL7Hk3G1UPNCUUFix9gCvhvsdWsJJ4ncGrkkGj0Q+fj6huWLa77/7cSlTl+7rnwjFjhZsSGmUTMWHKKgzRa21lbB5docfgRZeqiYQb1pXSdlYhQK1CoqFbwkaxQLqFupEwri/UpJcPa+DsCOKLbA2rErxh11lX6k2NkCivlmV2kmbvXriTNarUXo2fQy9gEt1arIoAgzXR+I0UFMjJNhslVW3NF6pPDNwniaYotVBfFKbQUnlhZF6tZjeOHh9NoU7apsOtP7Rd+jFYrOTNNCjD1PnzzleADRBUEpbUI4EePAUhr9BuZxotV7Gtec738dxTGNjV4ay/EN3f6Ki/1zvPfs9xccDg+cn50hzLSyoDpzf/uAC46bOrLf7qmlQzvoe880TizLPSUP9Js9l5q5vf4caUeGYU8/XLKUB0JbwCviN1AhdT1Zi4XJiOBIbPZXiGzIB0XruPqWC9RKdBHfJwQHbUKbYeJLs9Qt772Jsk0tacddMbeHoxEE5lpsSIXivb5te5Rmm68djyMCdH1CJJgQuFVKqdQy4sTkQeoiVEdumSieSuH6YaZziaGH87PEd75zyRdfvObL1zMh7pmnyqYz/PfQVeZsLYrkA6nbMOaZXNtKmYZpmnAh0PUGWegYWHLl/nAySZHakKaVgnfJMj7WarOL0NpCCLDtLXcXOurSiCHYfReEaRGaF0oBvKkcirLe/0IN1jppIsw1W1talcZC2gh9TNYPd5VcZ5wHJ2bd0hhpoUd8x6IVrxZmpBSeXj0npqf8wU8Br3zx5oG8/JPjwf1ju9qK5zZvq7x1GwTnVhTSejOuQSpQDSzp7Ydq/TSTh4hYxefx60JpP2zFsEFhPcLa+H8VBogYGt0JMfZ21KyVLm0QCVAmIK8oalmrPRBteDsPg1p/Zugimm3EDwVcpT5+f1T6PpGiUNpCnjKlWvXQdWviulo3MLq2ptE7nFq4sgrrEch+BlFAg1UaIg71RlVxXlchrElhtFZS9LTqOB5e4H2gZCFFDCWUFdEj0c/UeqTvE7WYa2K8/WNS3HO53TKLs3zW5MnzEQ2eUjLn+4RqZZpnoq/QCkNsLPlEqY3rUei7HaqO6WDp5xphakd83BMjPL3ccTyMoAvnVz2vr4WkJ5wcEd/h/AYdEi7tcItn5zuOJ0c3JNBAV8+JZ5HrFy/WsCJwWNXtfaBUa0NYr82O8Q5FPNSSURWbChKYsxLs3azSrkqfPE4Cpdq0vq4eaSeRUiB4MY5aM+2ddwU1BKflHoigRCRmfDZRsKx2xM2mQ1xlzBO//7NPaPS0sEeC58P3LtHlgSE1npwZJCG3Sh+tp7vtAoPvkVyQplSNCBYHKN6+p7ku+BQpOdsmK9D3ZzjnWPKCi2by1zqSpCKlkcc18EYqYQjkeSZ2iRBhrs3StNzj8M7RpYgLCR8C41FwFFMkrO0nD1DtVHY4PdCKmhBfFUcmdRFWIb/XBC6xzCdScNYnrROlHbjYXnHRNeZlYhqPvJy+8QucadkeF5vHYYJx3dYd06/CVrH3d0Rb7FZFkhMj2Dq3yknUdEyoRZrVBi2EFUVkP1TBNGSy+hItutAkAeoMEGmi3YY66/2ourXiswmDa842cHFICDYdbQtdb2LkXM3DKl1jmabVc5g4tUJzYk4FNadF1WxMLOfwYi+qiyaydLKCPhv4lW/HSqsNPqDRG+NMF/rOJp52sxzJ2YAAOSdSt0fChtgNLO0FSwtsNpf4ITIvNzg1nLqqBzqGzRnzNNLKPVM9cn7+LmWZGZnXrynSpZ48zgzDQJOeaXqJ6IgLA7thYJweQMC1ia6/QNzA8eGe6eEG3zlSv6GUGR8y51cd6nvu7q759ofPuXn5Mckpyh3en3A6URr0ydMNAaQxtYld18hLYOif0s4dp+mGvu9oy0RgQTQj3pG6jnGcULeisdaeruIREWpTSivUKuTiVomSbbauKg6PD51NaxGmcQSx3A2nFSczTqxtoiKkqBBt4t1oa39QrZWBVeihS+S8sN8PnKaFXAW8Wd5ambm/XzjrIYTCducZtgOfv8icTjONjlIEqSPbQXBYm8O7yP1hJnvhOBVc7PArRMEUBbbBOoXWbOqbtDL0jaETWoXj7Hg4Lqh4SlZ07R8359DmrO3jLABJxeG83YPzkk0YTcGLEJxFKs5SV8mULfRNCqKNGIXSGtqUFAfE2aacy0IMGamT9ZCDYzy85qO7W8Qt7HZKLhtOx39CoTP/eK8VLS1tPXpgi408zlLlre9SxKi2ulZ7bs1ssD8qYKP/4G3xEjHzu3MmFHW09X3tYzvvbJomAIbZFjUEUyv5bTXZEBADcj5Wh7YbCurUpqm1EKK9t/eO3DwlC2Vpa9VnuaK5LSv6yJwbrF+HrVsJL0LzFkto/TvLTPUSVotRb3q/3EyAq8YK8yS8t1zOZV5Q1p5fTIR0TvC9DQbKaY2oSJxm6Iaew7xBXM9+M9CFRF6EwzIzlYIj0nVb7o/GruvPzwlpYJqsMvju977PR7/8BOd3IDNoR6mR7dl71HCilAMSGg/LyMX5+2z9jvn0hiXf4zWx5MxUhLPLJ+zP3uP27kQMA5tdY5kGWrsBOdINja1EpDVaHOnSni9fvWS3j6T9lsN0Yr8/Q8ls91sj0Y73lGo6vbma20Gc2ejsVlnR7bXZzF5WXaEaHVl1BaNGo2sIjrIUSs4gQm2VGAMumvg3ISjWknBiqe9zEaO/tJmlKamT9SSh5KY4CRwfJlxM4CyLNQaQ9bW7O80oCe/OmQ53BIS+D3ivRK8MQ4BmaKYpN2oZ8MEh2dGlRCmmCGhtVTGhlGKUnaFzlGWmi4EkFtTTdd3bRWtcGnNVcl5VBetmnpeRUk00b3pCk2RZLA82UBGj6KCKYNSdXK24GHrTMvqgtOzXvzNnUGuV1k54RkKCpUx0PuF8RCRZGyFYVZy+Xuf7zVngrJ9lchFLiVpFvj6sCG7bXf2avFVaBtXVpO9WDadVfW71Epqg06QBXsDVmceFSr05DrQ1O1Ks7gTEv921azNdmVEnTNHuo/nuWjUDvXhvvULXqDnTyryitM3uI2JHBe+rpU2JTWSbLiQcQTzq+ap3p2s/SJ3F/GmjqJjUwDnTWGml6oKIN36YE0oVcI5GQIPZ2aLzpBigLUjoac4kKNEvBn0sje1Z4vZu5OxsS7zYsUwnyvzA6ZDZbq/YbTZsNjvuDwtLbdQ6kobA3fEWz0Tfb8m18ennLwmbnqVM7J98QM2Nm7s3jK1RnaPb7IkEajlwPH7BEJ+x6S9RKdzdv+H84oIyNk5FuIgbdtuO1zc3fOfXfp2PfvHHzJMH3a7w0YDKK1zsODt7ZtKWaebyXFjyA2f7b5E8bM83aNwxHR6Yjq+Yy4QPG+b5Hmq2Y2MzLVwpXwXuoB4M/W+vLUIXArlVmlTCGjxTSrbXzsualbQOsCikCLVOJCeQPLLY1NXHgG9YkpkDbYLzVsmkYNN4VFa3TaNPnZ0AtoEahJ99+ppNt3B+ac9DFxJabIARg2NpkZqVopFxyhT11GZ8tpyrsRDUNtYhRVpeiFRicLggEIxn2FTM17s+j0VNQlRrJZdGzmU1tmGh3yu4oilULevz6BFnFrbk7TTkXSP2ySxrYjw8O1RFO5o6mzjnYuqGUiY0eHA2YHASqeJR7zkuEyj0w+Zr15VvyAK30j2sO0yBVVv1VZaCUqhaEJdWzdxKtl0b/OLcGr6yugnVymHDHylooUpbbV7CWwCBM5eAjU6NGtFW4kRtpntrCLLaVVozhpjKujvnTPDWjFXNiBZwhUBYJ5jNdnafcFJXvV5FMQ9ocf7ttLi0hYYSXUOolrTuDDsjxpXASYW22ll8BDyUjKNRs5D6LT4O1OqJIdIlx3RY6NKWokbGCMOG0+nBJmFL5cnVllpuEDqCDzS3Q3wg+D15OaFhYr/b0loyv+Ai9JuEU+E0PhCiY8qKzI0YBoQNm+2W3WbDnGeWUnGygIt0fW+ZtHrP2dX3mG8qsbOPsyx37PuOVy8/5d3n3+bV68Ld/S3n55d8cToQU8/zZ+/z8cef4twFcpwp9cD+/AMK96TO8cHzp2y3T7gLC2P9iPP9D9jEDdcKO92TycQQqDPYQCmwlIw4XakUpvhvKjTMCUOr5DrZBitKbkZN9utQwiR1FZwwN+t1qgREIo1GFx2DY520d/TSKEUoxarvkgsuCLGz6tyJbfRg1sPWGv3Q4bSSOthuOmKE5TTSVmfOUpWqjlwSSxOOteFiB8X6dLqa/kXsmAy2SYdQCVJxYuABFxJeLQ7g/HxHzpXru5mlKnks1qtWc/7U2kCKmT0alhMrSh/EbJVixJJSCiWPlAqtWmsmpYEuOubTPd4rLvSI9GurKOKkUdWcPXXtYWpTcp3I2Tzp4h3BhzUN7U++viEL3IpFUmvyB2c7mBfDBNEszch2WHAS1kb6usM4m2YuS1mnYWqZliHSBJOPiN0soiYNEQ1431G1UjXbUKKtXk81pps0yyxVJ1DtqFprsylnM/KveEM1OW94cW3BKCRr1egD5FIBm3YWKs7bEMHM91h/SoSh3yCYI8OvJnzxUHW2Y4uCsKxGcuPXz/PBWHlihn0ZT/hs5JG0e8ppcnTDAC3j1ONCh0fYby/IRFoFg+0nWrmnlUJMW0sjC1CzWup9gxRNgJmC4IMyHu94enXFeDpxGq85O9uiqtTlwLjc0UWYxwdqKzQtXF4GikZK2XCaH9Dbj7m8eAbquF4euNh2pBQIacuSR77z7Q948epjLq82PHu65/LifV5fX/PkyXPu7wMuZW5uX4MbqbXn+uaWD57veDh8TD9Uyjhz1juKTtRUcLVwyhPRFYqbmBxEsQqYLoAGcsaE4s5eN+9XM74aGNU2yGLT+NZIyX3VF/aOEHu06SpnCmjLzMtCv+kRl8n5QIqeFB1lnYa2IVo1qXY6aTnjRIkhYIFRRp3eDJHz7YY8H8jHSNUNxSfyMlp1T6TgOOTRwALNes0pRnKJK+ZLrDqqM11nk/imhaU5OnVsWqEPjtAPnMbG4eGAiwNdzPjoOc4mBqZ4INHUUVtbw86/GgJaOLhYz64VQrTAmEUz4grON0p9PPYLaMCFAY8SXaa0k4mY54oL4DTbQEZhSEI3JJYWODyMK1LtT76+MQscYvkJNrys1kgXt8o+qr0LmNVpzR+A1Ze5Cj1Zj4Sojfxrq299oYpScwEe+R2N9mhhcpj+SawvoWqaM0utt91U9Su6SQwB5+LaSLav10lACYhPIKsNyFWmZUFcpKi3hU/Vgmyc2dGapLcYJqWYH1aFaR20eBxajQLivcMRcd1AVLHP5WZC8NTaCF7Iy5F5ORC0MPMaP2ypJVClp7llNW0vbNIOV2fUVUJIhD7h3Lssc2bOFaFjzBYE4rRjrIWuJbbDE6rCMh8J0iNVeHL1BNGRZbnGuzeULISw55QjITi6bmAaJ8aHI/3mkqF/Tt9fsixHHh4OpDgQu4HTwwOxgy6dE8JAq8rl/gOuX39C1RPcvCSGHcN2h0hjmm7Z7TYIC912x+Gh8eL2JTEIbVGGeM7ty084G97hnfPnnB4+pXlBdYfrelzvOB1GltyMUiPOUu+TMM36VsTsIrRmPVf3KATWRpfWnJB1+h+Cs7yLIG8N+OBRtRCblCIxQAp2D7cAOWc0CFIbrQq5QYiO6B1OKkLGOWXoCro0TsWZFg6liKdMleQjPiglK9PcUNch6onBBlZLEdQ10362Rgp2IilrSLpKx7TMqHdcbc+JzOTiKGqypfvxaGTl4y2b5Oh8ZCmReYE5227gxfpuqpBzQdb7rOutb+mcozhFZSBGb2h9BJX2thfepBBQgm9E7+gvLjidEofDw+o9N52ioiw5M+aCS7Zhf931jVjgdKVsWI6kIJi6v66qcxPfNssZwKo5wdOavM37VJ9AHBXLJBUqXsE1fdvXS87m/oYgb8Bi/TtLCiVX8z+pPhrjmynSifgQeQzEqWqylUdbmQu2hXgnOA+iZhurNHyy0GbvbVFNTuiCBVovpZGbUpriWsU7XYkm9vUGJ6v0I7wVjTbWBfWxfxQ81QUkJpqaLSoMT6i6EN2JMr6ksWHYPqU6XU+0lbaMOJRaZqJ/wvRwZBguaNXG/SEMlq41FUqFcRrJy5FcR0I8Y7N/DvuJ8XTL7c0NIezo+wiamXVGXGSpxaraWumHSKuF3B54/4Pf5MWL13S99SOHfkffDXhfiGng6vIZMewR5/n81Rdszp4z3n8G7cjz99/n7n5G3JFhW1AyUh4I08hVxAx+atKPZbFQmFO+52z3DvlB6DZPOdt9j8P950zHj0neoJDa1vjEBqHrTaXfdZRqr5GqX8O6haZuJeOaP1jXcCRD1y+WXxDMBePWjdmhOK14D1FW7HJoBK9ULeZ4qOvXL1YBin6lHNBa2Q2eWhdSb1v0YTbsVQy67v6rnMq5FYdVkaZvGYTeK6VUgjdEUlPPshRqawxdwonnzTQaXqyeENdYtKLSaOXIOxcdLjpyFe6PcHAGmXA+ggrzNNk9GGzhDzEgrtoQohYEpe+2xunDtG2sAeVgR9AYhYaxIMdpQbHjrIhQVcm1viW5+DSQsz0/X3d9IxY4sGrNrw901UZT8OLWZr71oh51PQir0f6Rtmo6p6blLU1CRNbwVAVn1ptH65fzadXGGUapPVKCxa/vZ5YplYCTQAjJ/IneCAeCVW6slR1YAtBj2EYI3pDX2PBBtdFFJQggjkWh1oC6hPcdWhYEU9l7b1+mNhsmmCYQRAz62Zo1k51ztDVC0dFMwOp07dcFWvAEHwklUprQ5muuLs9YWmF2nfVhqhGGx+keqUoeF1Q2DMOH1Fp5uL6hqGO7v2Cej/S9o5QjlMo0B4bdBbv9h2zShjfXXzAvLwm+Y3/xDhBhvKWUEaUwjg/0MdFy5ub6C/a7K2pNTNMNpR2p2bHdfsDNwyvuxxd88Owc8Y7vf//7/Pznn1KmO6gf8/rl38P7PbttJMYrehGW0y/R+oD3PS5sWKpSWiavG8FxOuLlhuoSQ9wz7N7nuCju+CW4CU9F1dnr3mxRjNHhvWMbBkQCS87k3NYWRaJi91LNhVwWch5RHCk5astAJThPjIngoZUJ2mS6Sbcht8qyLHT9hk6NFi1eSa0ZKHVlcoo401BiJN6QKrUsaIs44/bTKkYS0QjBE/BIG0EqKgUvEbynuoq2agOCZm0V8Z46j5Q8MWzOqDUwV4Gy8Jifvdl4IgvbITDlwsN9pbQdWk3jlmu1ez14vBjc0wehlhF96+E2QEZTwYeeWgq5ZbRZDGJTCGLe3JASIUS0NqRWYmcyk6YNCd7e7jraSrhxj/66P+H6Mxc4Efk3gH8OeKmqv7W+7Qr4PwPfBX4J/AuqeiNW4vzvgP8mcAL+e6r69/4c69tKeXCrTUts9de28tjsm1B4q5ez3bLaJFTqV/RWGl5A1AYU3q/VmmB5jiK2ILo180Ftt7SWblmHDzZN9eYqtga0txJfaCbrkNVo7y2wWmtb+3GP1WGjT7ZzhxjMVlUa41LJ6vASiXFYxcKKk7xOY93jz32VuiRwWMBOy6tn1W7q4DojxkrFB5O/NG0rvbgxNmHTnbHvN2iemU/XFN0AjqKOIhnvLtilZ4wPbygshH7LdHwgDY6z3VPyUri/+5TUKVrtQRv8GbvNHt877u4PuKFjv70i+h4BpuUNU32BayYkFpRuu6HkCe8Kp8MnpJR4973vcn090OrC0ibG44HL8x23N6843S/8pd/+y8RO+M6Hz/ij40tEH9ByZ1+LW+8DsWM2rqJhpLQJHyJaItvdhlYXKJDnO8vGKDMPx5cWtC3BCDSkNTPVKh2DUNpG59yEc4YECrEQhoFc2roJK2EInKayCl6/amuIAy8BHwKlzCQvSLD7L0QlukiYHJoheEdz5nmO3lHqik7HXCx9EBN9L5UQO6CgIZKaQ+ts6jrnKNXkUkGaTXZLow/gKetJodFvAqqOXBynqeJSYn82UMeJpRnA0mtGfTUJh69sOs+uH9C24GlcXQy8vj5akp33FCz5JHqHVDuBLHNdj54GugjeTlweT62K8x3aAgSHCz3RJVpZaFSDiYqjFcOi4QKSIm4xtqGTRq0ZFSFGt2LH/oILHPBvAv8a8Dd+5W3/MvDvq+q/KiL/8vrn/ynw3wB+uP76LwH/+vr/P/USACe4sJJ6V3qHDRGUkCKIHQVaXct2Zwpx1PBFiFq4hrq3OHLE/KaW1I75VmnG6nqbyvXoe7WKzssq9hUjjHq3llR8hdQBM8TbSTVQ10quFPPJBrE0eC+FGMHHRlEYM8zVcl4fP0ar1WxBTk3OIRZfaGh0qyLEOdMHeYNrCgXqmuKVOmjZLEooMXhqq5xvEtNcSCnSu0qJIP27nHVn3J0yTi+ImkndngTU4UDzPT4IebrhdJwoScllJsSRKAOCY9hdUdoVsUvcH9+QokPdgcKBzX7HfveU6fSM168+oejn0CZc7KhqWqmcDyaLaCfm04mLi+c8PBzZbpQH/wXz8Y4+bfHe89Evf8KTq+d4v+ODd9/lyy+vaW5iykf63nM83lPbA/iGlw7vKioGKiitMuVl3TjXnqr0kE/I9IKuv+CYOlqOuOYRqinzxcZUOCF4Q0aVlulSs9wNnawXK5DLQsMQ2j5sqMUzTtNbH/MyVygTvXek1GMt4JVlqAvng6cuq9nc/CpmQl8F7rbJBXIrpGC/P+VmaK5HWKoTci00bKLogeg9c3V41yOqdAl8LZYz7Cs5T2yGjv3WcTjcQHb0mw6ZZspSUC10zrEb4irWnZlP2XScTQl64nyobAfh9jjT2cDfXApAQ0jekZtlqEBAiG+P2841SrWQaheSRX9WXTNGVohrMZuck2aVOBbGU2sDLxRtZklznj9tyvBnLnCq+h+KyHf/U2/+q8B/df39/wH4D7AF7q8Cf0Pt3PZ3ROTiMQT6z/o8zmErsTqcs76ZTRJ1DW6xnlRrVmY/CoJVFR9k5cipnd9Xk3kVsQnhOnKnLcaCw+OdjawVQdSvMYWBkgs+mDYNsakT626quLWf9/ijq+S6rBYxIflIFMMheWcRho3KOC+UVqlqamzV1SCfF0Kwnknw0ETWct6vbgbLbX3M9iw18xUXD1rL5KWaV1Ow9CgFcNTJTN/RRTYxk4YB9e9S5on9xqPyjIfTzLi84VRH+uDJ4wPVZUR6Quc45WtzGYyFeb6Fomz7d/jOD7/Fm5sHfD5Qy4k3L27s57mcaPnId3/tL7Hd77m7S9zf/QLqBFLpNgPjaD7i8fiSLvV0vefb332fm5sDpRV22y339y/o0khdTnz26U9QLri4eo+zsyvzt+o988MnaBnxK+HYOWg5rf2nhSJHgg8gA0JDdUGkp9aR4/gRuwA+bWwBbgWJDdpsr6oYCNNaJqyyXXMICAYbraXQx/VU4BxNJ7quJ8ZocARVghSci+YwaYWh26DNSBveK8oJHyt9SCT1zEulhtWz2tYoymYtD3GNXBarAr0NuGqxiTzOEdStxJxCyYsJhAngLcNWyojkSivQx455OoLAtoN5KsyLIrlBzlRtnFphGReCq1w9SYAzjFbnkGWm98LSGtvkmSvmvVZQ72kCpVXbiuujrRCoK+PRNbxTBKNGow51ytIMymqrpSDBkQiEahPrUgu5Lcw52/eOWTprq1+7rvxFe3DPf2XR+hLLSAX4APjkV97v0/Vt/5kFTkT+GvDXAM72A0GcpbU7GxoEiW97aU7kbX8qsnLwdRUHu2BsNB+BbMc5Na+psT4EF4Ix5TTY4rGq1R1+HXGbiVqco09GMcVB1YrWEcMcddbrwlK/7fBpTV2HEp2F0cRgR46SlaUIFUdtAfHecDLMNM0Mq+QgBLEFvbXVhOFxobfvTezhjV1gyROPeHJzUGL6ObEK1mHhz+qsIR7XkOFTC9QC8SgEN9nARhylvKYLUOcRJELbsd1cUpipzTGOE67bkHM1uKWMEAOvb19x/4d/nxgDy3SDjwu73RO67oppnNF8x09+729Sminjz3rP3eGO1iaQRB8sWLrkzPWbzDhOHA73vPP8Pbbdc6bplhQdrin3d1/g2w05f8n1FzcEH+nciXm5xbUTQet6XwiNmRB31FxY8gm3HmWC79AqIL3x9pxpE8fDl6RwRnGwOTun6kxykbJMFhnZGnluBBdZO7KIN5yW1oaLq0tGrdWRiwnPh9RZ+pM4Yu/s2NUaGhwuAj4SS8HTWaD3OjjrvdCFyFSK4aeCR1ojJU/yDl0qfZeoan3e8ogiX21SXh49nZXYOZpb8fzCugBU08CpsmTWjV0puSISkeootdrzoUJp2Y692nFz3+iCIq5SamEzWGRgngemU2MqYveQd+Slos7kIYogDmutiDcRugaC72i6WFiUJLyzuE4tBVmHK34lI6tEnE8s5cRpOpBbphS75xVHwJ71f9wL3NtLVVVE/pRP8bX/7q8Dfx3g3XcvtflA8J6IcbdcsBLcrXoaRwbKymvz+DWImWCBKcB6dA1o8zj1CKal05Wi68RjOQze0DVeVoJIplHwziNtJcGuCemKUSFULJ7NyeND5axJq4rTRnTJJoVamKaF0rzhx7H3j2ufqNaFzZC43O1YltEqVW8YpNwyIsJ2SEzTyFQnXIjkYt+zyWwffbEraSUIzRuTzqsgtSJBcGu6mIueUiPowKSCc1tKhuDVbjy/AdlQ1eFiIOdA6AZ8KUjriN2GXGC7OedUoHMdeV6YTg+U8gbv7ijtFX33jH77DsPZc159eUOef0nmhi7tSD7YApdHbOIzE+OAD57ILcvDkZ9f/4SLix9yc//A0EPXD1RJTIsQY8Mxk+s9jdk2MYk4gvk7a4PmKExY8HFYhaEL1JGgaaUwn2ziLFDLhCsNcTNxeIKr4II94CkMUBtLsaR3Z11P0zHWYulcYj1R56x6eJyWtvyAa80gqk2JXqzhnqsxA8X6VVTFi8FXgzfoZCmFTfQ2fQ+BnDNRM52PTMGcM7XWFZW4Drow25mlQ1gvqpbHaD9TGQSJRhFZ+4o2jXfkpdE0rBmwYUV2LbTFxvUhRooEShM20XF17uj6jiVbv+5mzFRnweBzEQrWZ3wb4s7qTPLJMpec2gZLs4zdPNJ3SiuZpZrTh7KsXmurYpqz/mjDraCMQFw3lKqF1lY97Ndcf9EF7sXj0VNE3gNerm//DPjWr7zfh+vb/tTLA/06plfRtXILRt8lmwWLNaNBVruWQu8jzQkSIjTW0GdDK4lEgo+wTieRuh7VTZjpwyO5ZF0AVfHS0AA4NVSRrjukA5XVXI7H+0YIYgMH39gNkT5FlrxwWuoadAKVEa+NIXn6IZJLoQYYIna8kkprjuPxFhEbo3vvKNM1mxQIzaMxUavQO4crM3W5x0dzTQQf8NLRXE/rztAakGIQxZFGcULvoyHRnanlazvQ9Ttr/oZzXNhQim0W1Y1s95cszXHe7+m6C/r+jOPhBU5mltOBlLZ0mw39dss83XK4/ozOZbTOLNOXLPUlrrtlIwMsQmsLTSd8MLDmsiw411jKAe8zkh8IcUOrkePDR+x3T7i+veGdzY6zs3fQ4pinF3h3j8ponlYcIra4iYsEEYov1pwXj2gjTzPqTOWuZUFaxQXB93taXSk1zPSd4H02wohmomtmuK+VLjg0Wr7Ckos5Y1bniFIIbgU9hoj3ntyg5bZSSgqsaH1Q+l4QX8i1UAD1QmlQmtDHSIqe/WbL9e0dPphp/nxjOKH7wwOzNpuOZ2/DLmcPdtWCylplqxGiyxpMbVWaUFw2DLsa+DPXQq1QSVYtKUzTgrhMCoZPV+1wIZGrclpGYvR8+WLCucL+fIeEtsIFzOKVnINSrHUE6xDQhma1VXNcuIh4e6bLcoR5Zi5CjBf00WRPzQk006h6ebSgRer6zNVmR/jobSKbS4F/Ajq4fwf47wL/6vr/f/tX3v4vici/hQ0X7v5c/bem7FCmNtNCpanDNZOAqCjO2cNsSOoMrOz5ZsdBnFEZqoS3q3mr6+DBe2orJidxkLNNOMFuAnQlcwDORXx0tJKtednMhtJ3PWUtiR0BLxVZM1cbjRSFXI809eaxcx4RQ8k4gW7oMPN9YEg9WmysjgQLmtbVk+gUHwY7DtEYvFCkQQqEYn03H4INGcS0QNIU3yqhndBW6WJC3YKXHdVheREo1MoyHxGEud2jMRB1R3ET/XBJCIVxeiDXhVIDGhz73SXjfKAopLjh4ukleSpIS6Yx8wNP3/ttut7x8ss/Zl6uqeWOupyIWpBkvcGiQpVA7Hv67Y68zIYlUs9SZ6ZpZLPpmPNrYnE8vXrGze2Rb3/nOUrkcHOiLW9M0uEbTU0UHaKgzQzjVEjRSLAeIfRbKmoByLJAc0hcA2VEiR7UeQjFKmQGtN7h1ZPzSJlngx/EQEyBuIa15Fyo1cz1pS60ZaEVEN/wVEIwu1+tbb3L6mrjwvSbqnQxsiwFj+HMa8uM85HYbdjsbSNwziQptw8zTUyvJrKYlQq3Tv8dqdsZ0SOP1tZQ6183VVTM2VNLo7VCrWt7p7X1OGsZqioen5zpT71RfXNZqGT6TY/zkWlZ2PV7XOz44vVICEqrMHhBWraUuGh2y1Z0/TqccfRU3orkhYUUI7NmgvN4b0oAXb2nlrdiUaDON4sPmA+U+YhoXvNlneVbVEWCGfC/7vrzyET+T9hA4amIfAr8L9aF7f8iIv8i8BHwL6zv/u9hEpGfYjKR//6f9fEBMvDZ7YEyH/j2e1fUtoB6O4+HVdfmBOf8W72b6lqFqZoWCAUv5rJT8NHhMaptTHGdzmJkhTqvFhLDfT/udmdn59zdX5NChxcopZG6aGd95xH/2DdpSLPpq7bCaTwR49oLFJt41VKJPlGrsix1TTBPaFsDB1tDJZFrRnzPdhjWKlNIrjAEaBVKrUQnDKnDpUgTC9zVZj7bIEoIUPSe5gqbPpNdI+SFqp4SIrHbUOaA194sW0EZVSltQV3HtNzSuQDN4d2Op88+4P72ntv7z1AXV4SNHTNSPxClxzvlOM0s8wPLLAQPmSMw4TxrePbCMh8M4VPFpqkhEvqOrBV8NHzT+hqKNMpyQ+q2nJ/3fPzR7zB0PX2fObbMvMw4CXgZbMLslKYTy7yAOubpSIoWh1ebBx+IneF3slaKADqhXqnibIGrtgFcXL1jeKH5DYTAcJnofKKUQnVmKPdSCV2APnE6nSjV0tcaxtt7TJYXb8e9LiVaNjz9NM3EhKWZuYKkaglYrZI2G7x4Wj3gmuKaUOYKPhFizykvDJsOaZVKxXLiOlQ6+t5aHerVpDLNwpH1sZormaqzSVBCAIEkJlma5gkXe2oNlAa1NJZsz5JzAeca0zyDCiF1FC+clpHFCXMpJHF4Z8d01xrRR8OzBw8e5lINn+8NIvDotil5JARvBnv1iE5IXUW+YmiwWiu1TaBGh/ZB8RqsKq8N1BLJGu4/Xw9OVf/bX/NX/7U/4X0V+B/92Uvaf/JyThjOe6R4cim01jjd3bI93+PEFoe2TLjQEVOHakCpb4+VCHZUxSakxpKD6Dy6IsHt8zRwC9ErvpnkBEzJrQLH8YbgBb8ONWLfr6rbxyK42rFIlei87SbqreRuluOaonH3fexobqVDOCWESAzesjaD4FokF9vZLPnQ+hZdqLg8451ScmCIHU0Ko5oifJ0ZrhNdTxLYasOXAW23EBb2PuHSA1V7jtOCyMgQOvb9wHRazJhfI3RbSgkm9AwB13XMpTEuMyH2VC3M0wkaLPNC8Abj3O2umDPk0mjziO9Z4/l2JN+hbsH1PVoKMZ2T84w0i3tc5hldTsQ+4HyBmqiLEWSd2zC3StGPCGFDR2F6uONUZ6uIfW96Q5mAedV9dfjUQ1OSX6EFRXHB9FkUxVfB+fBVX4pi5N42ms1JRpKf2HTnHPMbagMlrPQaoWomxDVucNU/DtsBbR3LgunptLGNjlJmspol6nQ6Ep0DSaS0IS+Wt6DyKA7v7PiVs+X6NkfNFsuIC6bcbyPiIl56vM52atBIjDskRsaTVTatLayO+dXaaOqA2HkinpaziZidoNLhvND5iHc9uYql0jUhL7bwLnmyani1p1VV8qhk9SuRxKAUtAYhkTY9XYxUlOm0oK3Rd4EpG0ACdTQctYkFXzc7gbSqVJ3xEhAfCc7RWqG1ibqMJnZv1XqJoQeX7BXM88p2NEjA113fECeD2Z3UBws5bhC3g2Wb3s+kqOw2HeI8y7zamAJ4Es6t/CxZY/nEDNLWv7MjiZF1jTDitKBtXic1mDHYW1ksIsQYqfNsyUE+WthLNX1brgUfheSD/ZC14Z1Nj1S2q7WmkRKwNnx9iKQYcWKp9SXXteK03U1RxHuWpRHFEVNis0u05cgmQQyV+2KN7MACIVFcIrVzw9Tkuk6LOxZdWOpIaB1lqRZl1yVEMik2pvlg/R7X4XLkkM20jy/MOhLLwsYLy/jy8dyMp0OkN/z2fGIzBPL0hkZH9AM5TZRyYs73NAdFFKeWMqYCobNs2VJmqJnNbk8r2b52lLYszNPIBLzz7Bn39/e4PDPzgLgKnIgh4vyGWhQnC+JO4CpSNyYPCorUVVJUjQSj8rgNQG0mzXEBtAjqI85FogoRj7iF61c/pevfQaoj+QGvNoRRG9ebat9HJFiT3FVP6HvC4KlNqMtEXmZ8l0g4yNWqpGwyFJxNCQONKrLi8DMuKo8pbFmF6hNzgzabu6XvLKm+1JnalD72pLAlt7ZGDlZ89Kiad3cpdR1+FZyHpSmumDWwOAtXzyWT0tYq3fX4mqInV2VZZtQpPjW8KsGbW0DEkUloscAmt2ZcLLng/cCUPUU93hdccIS2giRiYGl2nPVi7QVTFlS8WnKeifgrSymm+2yKloluDTnKzhNcjzaPd4O9lr4SxdPQr2Qof8L1jVjgZB3DO+8IjzmiCsElkibKcjLTQTO3ANoY70e6vjJsd3acXb+V4FcnQFvBhWITNnERJZqQViIOI/2WlaOlGqhV0VbWAGYbeDzmPHj/CNVc0ehr/8hQTT2bzRNO44RzeaXJlVVDtboScOTZgIpNm9mJqG+POd6bzcVJo9RKro4UDHUevcPVwv2h57Mv4bMXBz5+c+L+YFPDqEpwidyE9y8j/+xvCL/xawNXm0JMR0bneJgXyD1jcRCVxm493nrmekCAXAtLvUOYCUSGPtLWKWFMe4IbaHUk+MCu3xPDjsOpUStE1yAKx9MrYAYxZXtTTx8jM0JtC42CdJ6kjrD2H/thwzw3YCB0jZxPlsepjlwjTTt6v0O8MC/3uJwJPpFW4MGySjRUrUIZthvEBVv81lyG5oO5C1xibgVZZtya/hSjPVCl3OPcgLiZeRxJIdBkrXya4qQhtZG6QJaA8z1aC6VNFknY929f8+Ac09o/rZgRPoae6JS5zPjgTEpRKz4UO465YBInEtH31JzpopFzH45r+I3zlGZ953E62sCmWRhzbSuhzUGrjZKtz5ib2Zxqs960NmGZJ6ynbQ6gpgtaIYVqFZdAq+YGkhBs8h46GrK6ahRpSgqe6uwJXkrGt4JrFSdKzgviWTNMoIv2NeKj+XqbBW5rexxGZLz6lcNowz8fE3FFltEErdU82gTEwzid+NPOqN+IBQ4MMYk2WpO3EMmsI0PfY3hlT+cTsU9WfrtELQt5GY3uEYJVUs0sT7LiwFfpNGhv2B8BcUZ4aOoRz4o4d3hfkMekIDH5hh1JBG3WC/POxvOtqWnZHDQXuHryLtzcsMyvQVdsk9q0ty5tdU1ku6HEGSZH7cjTEINTJgE3U0QZmyMX4f648POfZX7vo4WP34w83AeLElSh0BFI9nBFq35//rDwDz/OfP+dif/6f+WK7397YRkXCD01Gk6n6pbd/kP6NUSk3kYimcvdO4x5QUkE39vEMHiW1vDe+ly5ejb9Jfd3MyFdo/UA5Z5lOdD1FwRvIs1cTpQGwW8Jw4biAqqZyEyrxfDW6+4r4ombC3x/hWSh6zbsdnuOp5HeR7QFzs4vuLt/jQRPnc/Qeaa0N6TBpoPOCeItXa2WSp5PdF1nlrYQcd3G2gDSk0IjuBHRQq7ZFgZtqBRcf8Eyzyw12+TeCy6ZVqvHdG15majN9HGl2KDBOQsoF3HkeSTFBBJYqqG3nIDmjEojRGMCxuSoeYFsi3B0Jg+pWi2FywmHacSJ4+rqCeA5nkaKFpqaHrO1QlXI1fzJLqiJyjOrvGIVuSNvYxJLLcQY1u/biDtoteNoMNdAVUdeAawpbHBtdRm52TaPbFpBIaNeycX630u2ZK1FKurNBglGwVZd6cgoyT3mrpj7xEkgt7bO/x4zTwwkaoNAQAriG60Y0+7R9vaNxyUprDasinpPDD3Bm8+slpm+HwjOMWdzBMQUiX2HEEhRaDlzmk7W3xIhOFMFxRgtyEJs6igSVwCXg+BWcJ9f7Tx2bBWXLB9yPdLCas53/u2UpzlIIaFFEB+oruPlq89QyfjQ1pBqY1dJU6Izn2Oulg1heiBLaA80SzBKPcs4c78Ir+8aP/vowE8+OfDlF4XD6YyWnhtLSxciC614bqeG+BNOjyDG9u9cw/WR33+15Wf/7gN/6Yc7fvu7Gy73I905eF+p0x1T/gmZjrOz7yJyzml+SXl4jXd7ht0zqo/s95eM45E83dGlLThHv93jNNCrI/Ydx2NinmeW5Y65fEoXz4kx28KHErTQlgNd8ISuR5dqzo20YZ4XvGRCGkj9O/TDc7Znz6l5JSH7a1Qnhn7P4TAR0zmh2zPHhTpOlDHDkvF9MhCCdFTtKe1AkwMNT+x68I6lHBA/0KWd3XPi8X4m0Jn9LxfGJaOu0NQxdD0S7NRAbmhWlhAI/QAqVpVVo4sEtrjWcGGhAr4bbFPMGWkrUp+MxDVoWhpRvSWthQ4fbSGxwYzaUVyd6dceNWPN4HEuerRatkdZMP6aWHwm6miLfSwvDh/NHF+0mSdIMddDjNCMIVgeaSPiCMlOMq1aJoNzHu8itYJ4g3y6IkQ34wZhXhpenAnbPZSidKkjL0Y91hbIotRmbZyQElIWwJiLrL3ymheaPg42bJi41GpVmyhSLF9EnKC1mPcaBeeJLllV+DXXN2KBAyWXsuLIxVZqgTzbrtJqZhFBteDVU9pMno8mhlwcqevZ7C5Wr6A167VlqJUyNfCNxogT+xxd1yHOUUXWfoK3rNNqzenHRiY629HZWXqShZKUtw4G73qCP2PYXuDCwGG8Jy+3xDAhbULLDM2wNFWV5tZEo+ZwLRCjkoJZ0+Z6x0++nPh//H9u+OxNx+3Jc5x2ZN0Q+jP2cct0/4a9i9AGlqTEXpjmiVb2eHqW+YR2ynJ7xPsbttvn/L0/FN7cVT64WPiN722IXeb8vEfyTB8FpmtOLXD+5EeUeTE7DDOHww3qFloWnHScJs+nL2/Ik/Jwd+CnP/0pZ092XB/g/s0bXPM8Pe/oh9ckH7m9WeiGwvzwkhCFqc688+wJ3/7gXZ69c06fNtR6DTwQh3fx/TucP/s+01hMUzc/sN09g2aT5fPzSx5pzXVFfh/vBmq+ZyoLsUHzgbPzD0BO5DrR9UIeK8s0ErsGaqlSfddR6SgrrAEtBv4sQqs9vXRI+YypHlaoaSJrQaYRWWb2Zx0hOly4YDweCbHQxY55kUezILUUc7l4q/7BUtWQ1dOcLeUtpg21ZqIPbPd7vBPub+9Xq5OySwnnFK2ZWgtLrYRWcNGvTXZvfcJgbh6tAJ6qyViEQHSBWopVRWpEXmmG9goxrQXGiu6qSi2gOAxSrMRk7DikkPpGWAnUFZiKQxcDuDrx4BrNOaa66jRDT6uBvFhqmQvR2g8uUGvmkZbtgVxMxG0JceZCqXm2Y7AqtQlhFVA/kq6db9ai+JrrG7HAydpctxTdQpmWdZAQ3qbUiyo+Ghv50TxtdhyBkm1cvE4tfbAhA074KkDaTOytZZZqeaBGJqlI8wbskwZiTV8VwbtHJwKY2MkoI44IbsD3l2z793nn+ftojHz55obrl3+I84VWminaXU9rAwDaTkz5ntBmOhLdIPRpx+0o/K2/O/Lv/j9f8+XhioqnqlCx4OjkHLevXzPP9xykElyHWwIhKH1MFCmoKxRMssLywCbuuGu3zEviWLb84U8b/+AnB7ZPE08uCufbwF/6jaf4XOliZbx7TdqeMQwbTg8TDeFnP7nh+s3IYYKpNvrdjvujcrXbcPnku3zv+x/w//2dl/zgB99F88LNyy8o1fP0/Sec5IJ5Tnxy9xFOIy/fvGL4WPj488qv/zhxfuaYpoVvv39FCDtCd8Y2belTYhofDP5YJvZne07jgZgiQ78BtV7Q4TgxbN4hReH65po2viSFzGmc2WzepWjheHjFBx/8gBdf/pLT9AkxCp7KPDd8t4OGxeipQ53gElyeP6Od7kn7Kw6T4/4wkQsMIZFlQhGmseLjjv32u4zjF4h/Y/BIHLVmQrLWQ602SGr6SHC2xc43MZ6f88zFjujSAsdTMz5fiOw2G3COUgutVqpTWrRQcVlx6rpKk8AGYa6a08K7xqKOuRTEO6K3nF6w58iqSL9WoJbvqtWzVHlLSVljnwjVhnVOHY1lVR505vIg0g8bTuNk/TZnukzVAK63Y7MEfHoM4il2VBeDZ/j159VaIzghhWTiaBbrnbtMcOvzu24M4oRKwa2TasdKZP6a6xuxwKlaNCCt4WXFErl1l6iWiIWYSAPFdDpiTWrNdqzQknEhUL01XH2KoB6vmJ+wWZK8OIuao1YLiVGz54R+Z3hqFOcVpxbzhjMMs6zcNwSS33D25PsQLhEGnHcsdaKVBZGFMh/xWqwacg2Cw7uBMlVq2XB9DWdDooTKL/9o5G/+vU/5g48cx3pJplLmO8gOCRvwges3XyAtE6Xh+wGNA1Nu+LkwPtyx6Rw+KHUaKbUS3DmlBUJpHMuBZTqx7zZcPwhz2vPpy8z5NvHR51+w6ZSLofCbP3zK2VP4+UefMJ46JDxhaQ4JnmG7w+fKxe6M06mgRfkv/5V/BvyR957fc7ZLfPr5PVff+jWCOg7HkZcvHWnbc/n0irPtluGy43jKXLz/HL9/wm0WpqVj+STym7/xlF46NrsNt/czXb/D+X5lABaenV2yLNZz2gyJUjPnV2egl8xz4Xl/xTJ9QDnccnW15cvblyz3r/HtiJeeGJ4R0iu0nXDS4dOeYfeU25tfImpJUEVt2tpOB+LSyP6C63Fku7vC5UxbHvDOWhbaIKSnfOs7f4WH+79L40itR7R5NGwYl4VWFO8CuLpCUFcsUhXUOaQJLVebRobAkgHSmlfg18WtguvIpTGPE9FVgrPFJ9di/cbWwCeqC5SqtnCh1DrjvYJ4c2E8kjzW23iaq8UTqrVuvAu0apkNtEyjEpOBVmtbgLJ6Q3uaBBZ1VF0o8wlVJaVArbPJrJz1t/NiPbngwMtjOI31r0UKrPe0PciNJuYv96uly2nEeSg1g0Q7shJxvqBlpmQlq20IX3d9IxY4sD6ciSRtWum9GeSNcx8NKa4mlDQXwCM9wfDG+pZYYH9HVoJXBAuHDmvClq5kkpQ6U/mvE6ecF1IIVuo78OuCCyYnsapu9cW6Ceo9oRs4nI7cP5xxd/eSu8Mbcn5FcGbgx2NC4LsX+Ngx5sZ9Vv7t/+BjlI7nTzbMS+Xl3YY4dHTjglsWYgz4TWJcFpbpDUMaCCJ0oTPYADOjL2RVWhQ0Wh7rxg0ogcMy4VJAaiXVzD46aDPHceH+05nz/SWjzgR3zt3DzIs6MuoDN3/rNbmA74XN9hbfOY5HZdNXYvR88umBZ083SDxjVvj7/9GX5Hbi4mzP1ZN3+cUvX3F8eOC3fvM7/DN/5T02XeL3fndgd5kI23O6FHnv+Zaz/bfZnEeiq8R2pBs6nr2/ASLbXaTUBmHVxtHe0nK7rv8KL+WVWgu7baIslX67g8un1PnEZRBuWBA94+ZwYH95gd6/j5cHHu6OSJ05ezqgRGIXyMUcCLFb8xuCOTXwgUWVbtsTNg3Us5QFUdNrno53tHKilJFaD6azC1sboBSDPWB0H5xYBKR4B7VRUMIQAYsNtCiDhoTImAunOrMZOhqKrj1LrZNVXWIPrpNGlWa5Is1saggsxexSrAtGcBbfp2pDkygCLsKktGLFAl6J0mxhtjAUG7o5s18F8ZQKMdmxU+aJ43gCbQTn0VroU6bVRvDNeI69cDw1ptmAoq0VVCxxKzgbFARpa21XiKuDwYuzvnd7jrY9Wq8p5Qb0SKltfRZteKHNczx9w0NnbEGzCaex21YOG7boNTXngNm1BO+7NVXL4ZwJ/XTlv7lm+GgRv+Y2mBfVuVXX5R4Fh6w/TMFHZwZ1sFIYJc8LOc/45C2ftNlk1osn15Hb159Qw0uKg8PRmqdOR4OfZ0+eJ8Q5bu9HcnEwd/zO7/4x5+98i6Wdc3svHO+FYb/l5u6O2AWG4NnszYQ89IFYZrJWPB5tDub81lycgkerMtbGm+NM8LCPibEUkgt49UgXzD60iYxzo/mePp6ZeyLfc3hQjsdbrs4HPv3sjpf3RxyRyyGj48gPfvQhD8D3vvcB1zfXSEg0qbx685q7v/3Ai1cjqVso4ys++Na7/MYPf8iwbTx/sufnH3/B+++d8Ws/eo/n37ni4X5mOhz4L/zld9n0A6kLHG5Gtl1HK8q7T/Ysy8ww9MwzbDcDrMFDIrAdOmpVSmkrUmq2ygiIXWfN8FI4aeAqPiWmDpqjlZHT8QEnA6qZZ88uOUyZ0+HAdvOUcbrG+UitHrQimsgqSDvgZSbPI8viCGBuFdQqiPrAT3/6/0LLSOcCuTR8tP5xEyV2nqLVfK/ebHgirCSclZSxkkmMzWX8QyP/mOOlZCGmRBUls6DeW5jSGmVIs2egaiOIhaNPteGcN8adM5KIc2Vtz1jbRTUTgme7TVAsKWss2QYY0XJR/Crl0FYZ+oisYdGtnnBtYReVJGppXhXqo3yKyDIrzSK0OB1HigacdGgrtqitXDnTwDdTD6iAJFQ6aglI2PHBr30b58/4xc86dHEIIzDTmlCXDdN4ZLNx7L4+NfCbscBZ/bYa31uxyY5rpJR4HHGLrPYmS4FhnW1bw5bViI954VRWBPnj0AJbuCzvwHYIBaMVKFYa02jOGrZJHJISMXVGdvCGYa7NDPtOAt6BcLRReTVFtmpGi5rp380cHgp3x47f/8ktt9dHxpz45RefcToupOEpVOXzV5mFDXVs5rNcIwEfjve4aJ/Tk42E2ipLXgiYg+Jx0rbkRh8T+kgezgXnF46nmWgoO24f7omu4rc7kq8oE3k6EVFOJ9ASOY8DP/j+h9w9HLm82PLLT7/g6sk7vH7zwvSGbkPoMvH8gneebfnxjzynGkmy8N6zDa9uDjy72HP57hXqB6rAs2fK9z8c+PzzyPs/esqTS8fdbATm7aA8PR9IweNE6XsjAsc+rKP/RykBIAYwCN7Yf1UjUus6fZ+tglfl8mLPkqvRlb3j9k2j6wqyvWCcbMrnk0NdZ8LjYeDu/jXbLjDNBxOU+oC2A74FahY0Q5NA1kSXBubxFTkvHOcv2Qx7JHa4eI7mGZdndMmkLuIdVLE+camYm2J1rDgVvEJ1lsVAs5BlC+NuxCRUKi0rWoWwOkHk7SAO0Gb4rJWUq1jew2MojTXeZkMrEYnOkZeTberBG/rcLcSYyM2OsXgrCFqz+16dklJDpCJq2H7aAjXT+UzWyO39BOKpGla9YGCaMrUKuIHoEmG1vbVqSoCqFa8OCb1RfesO313g9Yx5WSwWMERCsEEKeoLWiG7LOJ0o+cCwiQy9tZO+7vpGLHCqj3I1h7hgAwRZdT3uMRe1GQRyRYSv3NW1wjPOrcO0Oo+475VBYgjvVQRqoSF15cPJavPQlYCg69SzrkoSR9CI88GayM0ZZ61ZKHPqesjFTsUCWh0xVrqtx6UtCxPl6Og2G+r9zKlm7h7uWYpnLPfE5hE/kLxHy8I0F3CWKL60YvkTMZFrJXkjvDb1jM1op1QTVj6/vDIV+/0tXedYKizj6oltlbwovY+cbRO0lxxu37AfHB744a//gPsHO4Ie745cv/icu2lhs93zgx/+mIpjGAKvro+8c9XTR2VpjXEu9EPkwyc9T58+QVohDoFd53B6z9Bn3nv/EqeOs23kdpjZBGGIjkNO6Dhxdb6li44UDVVveeePvlTbmORt/9huYu/BrRVqc9ZUb1jqWkoGSxiCo2gjZ3j67BneXfHyRQ+nDU0PxBAYp0rJjtgC2/7StIQ+MS2FIjOlOrRFSh3p+4h6x2FcoHiOp/I2PnKZMl3aMueRISVcKWYQPy7EIa2tEaHzwRBFreFawUtlyQ2JHcE7s/E1Q3GLswXeOcdcjY/ovUN0BaBiqXO2kRtLDRXL41jzR5oDFSXGxGmeELxVmd6t+s5GbY3goawDNMs+MVhEXWdqFmOiJAeeClJpzv4yN5jm2YgpzZ5AlWaZFM5RC6SuX83whiwT0XVw4BEim927xO4dDgfHr/3ahk3f8clH17x4/Qs+/+QBaT2t3hPCLfPJsjaGpPitIppNgqP+a9eWb8QCZ+vRStgAa/qHxwxK++/tiJ3HWo9VTPsruxo2AYVVge3sByoilmMpprVBre/mxFvPrlnCtmltHOJWfr5zeLWS3TlnFWBrSHAUUavaJFHbbEdbJwzdQAiOmwfhZ5+d+OOfvyF0l6T9ltevblB5Sr8pyDJRl4oX8/15UVLfQRh4OE22E+KpueBi4LAciUGoQUAspMM12HYBpiP7iw23hw3LPDPRTJNXGj5ExruMlwU/NEo+MYSR733rQ7784iUf/+IXTMvCd7/zPofTgYmK18ibz18xnx7oN5f8+Mff5r0fXdD1Gx6mmff3A4d5Zn8eiV55/eae1jpeP3jOu8zTS8e+v0RrR3AZdY4nT/aEpNwdZ46HifMhGtY9yDq1s6rE/m8bkV3K48MBv+oMWZPKnKf5Zt5S1VUOIZYPIG7VW3l255eEGKmTUpYjnSib/R5FmEflNE/kxbHZnEOYmbAFb54eoE0UnUkpEENjmQspe0Qrl9Gx6RovTieiy+Qy44MwT0o+Lhbq0iwwyMUtIW7BjURfoAVEAnObTJ4UPAFdk7qcFWDiKQrFC14dTnWt1cyFgrPIQZN/WH6ral7hEvZT3HYd4npKVZaymHOneUoxhH/qIuLMNRNCpNXKMARKnnBOqVk44ulDo/PWqsnZMWfHnE2iEZw3gbAvaHDURQmdx4VG15nRvtZix3DEhkjS8/Td51xdfMg/+t1fcvP6njelcvPmBuGWeZrJuaDNM57Ml3p23lFLNoipbzzyGr/u+kYscKprFqr3axUWTDPjZPWqPSZLrc6C9UjpxL39ZSufTZi8W3MTmvUjZB1eWGq99TGQSltxysF99eDI+m9dtc9tQEVrEoul2VrzRDylKDVXnCS8W4GJ3vPZyxP/8T+85bMbz/3pjFIyyzQiQPIBR2Xb9Qz7uGYoNKbTyGZ3xs1pJKtSWXBaiZ0dW1K3oZVmeiD1YNIqWhB2XeSDdy759NNPqboQnN1cQTpi1xN1oc03THdv6GNing/80U/+wI729IS04Wc//QghoVrY9hf4kHn/w/f51re/izYhLycO42sejnu2QUg4bl8e+MUkfPh8x4+/t2P85MSzq3PeeQdOI4TecTp6ZLFJ2FI7Xt1nPrxMFiq9ViiWI2D+XlnbCL96b/DYUni7va2VHryt2L331FpXZBCmd0zWO7Js14ZrifujZ0g9KRovbxxH+s3A7uySh9s3dN3A8dQ4VSHJliVXyOZNrksmbc7Js9LLQucavj2w9UISQ3wXLcR+R5fOuL1+YJ7AhZ6z8yuUQEwdh+t7at+QOOBqIwWz2c3LjJfKdgjUPCESmKrFFHpvGKJW3Sq8BXX6drqvdfW7arMFxFnUphMhaKMxvUWL0UwoO3QBxHp1MUQT6sbEIxdPO7MYNnXk2ixZTDy1KMcZxsWDtwGQNovKbM2vUYKeLnbmdc1QikMwgIOSTcyM8tkXn/Dq5T2tHXn98ha0UPIJn0ygXLKyzPY97ffJZDayZq00y2Nw9RsuE7EM0PRWs1aLIaENYLkiy1krMbVqToN7u7dLa2bHWrVwuk5brSS2Pzv1KwjTtGwq4KI3f5tWO6Tq2udDVmLr2tNbJ68qNsmVVXhpPlX7vE6EFB1vDjO/99PM9eGJiSBdpelIFxphUKo0liJ0MbLpI8k75jmz4FGCjezJbFJPFGMmZTxTNaBgTA7NC3OdwW0oqixz5u4PvmTXN9KQ0EVpoRLEE3WkLJ/T8jVF1o8jlSVDKR3BL2yGnlOdeXZ1Qbe54HhaeHX9OR9OH/IPf/eP+N4Pvsd7753jTzuurs4pKlzfPfBk6/mnf+MJHz4/Z7tJZCl4Hal0XN9G6snsPN0mMDhhKoXTtLAdtox5Zlka1UEfHMtSGOJ61F81T6yvOdpAH6v0R+sR6/m1va32QjBoYm2NEMzXa+lYQpc8tQ7sr75FySdEj+gycraPhmUvj44B6M+uaNGCU06nN4zLPRyh7xKUg021dUb0wOSUmzJTgtGmg+4pmM1oe7YlLJ7SOtJwzng6Mh7ukNZoS6P5ii4TndgiFiSSl8yC3VviG1JtqGDH1rqGhXs7FmqltoW0DiJay7jkaYUVNimUvACgmIVKxJsqIWMff4VIaHPGL3QLTooNRZwtZmUc6VIwD6g6ZrFmggkTLKNVRajO46QjiqkbRGCuxoozPWjDwnwSWgvaJg6HA+hrVBteFlqeaaXBIjyME95vcb6RUlgLCyjV9nfr6X199QbfkAUO1DRkIayhsY+JQSbZeMwhQB9dBTYtFQTxjrqGg4R1MbNjpuMrk5otVoZBquaxlEDTTPK2uFoepjVfDS7sqcUw5qb0ditr3uL5nDgTTILtWM4zlcqLVxMvbwIPC8xN8S5SyogTj3MGFFia43RamMdM33fMeWHKmfl4pN/tOY4jfejog3kWK44tlRYrY5voPGw6IVNoc2YvHu9HNoOS0o7P84zWQB8WejdyzCd6L7iWkWaKcEIiBNhtI2f7gftPX7PdvcdxvsFhFWrOhSCBLiScg299/31ev65cDpXvfevbHJfM99674H6c8BvP6HbkNxO7JlxcWRP9MFrlEyIc7gsX24G7OTPN0aqQvLBNHtRRzz1bZxTl26lQTa1AL42zwRs7zFld7daJpK7Vvb3Ka0WHVeaqsm6QDkJkswvgMtevF5xsUTWacggdm+2eN9M9EiKH+1vm0w2vD1+QuiMXTz5gPgha72jOc/nsW4w3X1JO12S/oZQd5DekoZG8MC0Tw7ClJcecKod5ZrsJzPNCq7PJm1Tpg2eZzUWhsprNPeQKS5PVVrjma8xKk0aXKgoryshTq6MVk4k0islSXDTbVrXcBqGtguB1E9eGhPVZWDHgDVbAhMXx5bYGhBM4lUgkkgIEV+maowT72U7F0uTEe5xEwJOXxZLtqKSozPOJpY2gwQqKpgTXiLGaayXDnEGi57REqBvG6YFhs2fYGNyUGqxuF30rUm4qqHdvgbV/0vXNWODeDhlkFTdW07w1GzTgDXwUxFuPbZ2kiv8Ky2w9OtaBhPHV/EoWMcmJVV9INtW3eIRi2Q1VETHr1trOMO2SN1uJrqJfJx6JCVyC5m1i2uDzT99webXj3Q+fsuSFUir7i0A9zBxvF873e8bpxDxD3284zDdkp5YloWvmY/M0YDod6JzDr9kBJTeGIdDHxnARIGy4vsmc5omqjfO98sMPNkDg4TRyc1+4PBckbZluX3F3/1NCK0BPzpUumsB0mWGz8/TR8+mnv0Ba5Y//+CcM+yveffohuWbu717x7Ol7aziJMOcTLvX86NvP2O03/KNP7ridPZfPzhnnzN2biYu90KXG/anw/CJBVL68fsVmc4aGRu89n34+Mx0L6oU+KdcC2/OB2INq4Xf/8MCxNe5OC5tN4nvvnvH8SkHWPIIA22TxkNFbk/1t+O+6wTl97GVZnd+aTVxjgCdPz1imhVo3DMOeOU/cPxysz+qE3cYx393y4bsfMpc7fHxK0pGSTyycE4fv8HA3My8vmEvGl4WezOnuiJw7dvutfS0OLgZPn3umaaYPG6aaqZ1StKHziNaMOpu4hvU0ok0Rr+ArKUWiCEUq02xhRiE5umR2sND4yotZ3er8sWN8EywVnkotNn123h62ug4vrE8jBAmW89Bsg3ciRNaQnsHSQJbSOBahVbcm3TWiB4djyZUmM3akzZZbqnXNHxaj2rpHp9CCkKEVugTDsOXhWLk7Lqjbcpobvku4KGsVa46N1jBbXcukUDGoxdqW+Jrrm7HAiaVd85iJ6lazsDicD0hwa/CMmC1DMIa+WNCKE9ZexCPSaDXmvs1yWFd4Z8puAZCGF/8260Gxqan6sPb5DEbpBEo2eqmuQ42GJXD7ENFaef+Dd3nybuT+IfGLTyZyjcTmmE+ZELYseIgDKSnLfCKFzvoqCswH+i7w5MkGlUaKSggdJWe2fc80HXh1c0uTxLQ46vHIu+c97797xjzest12aJt5+ebA+dkF7394wR//4pr7w8zp4QWSZ0I0Ai6iTCXbkaxlTg+LaaDmTN8LrRWWqYCYPGcZJzbbSCbj08CuP6NOD5ymhaGL/PqHW47zwuGUoXnq/MBnNzPvvntGWRaWvnB/zHz26Ym5POBQYs2cppmzXQI55/Yw8u4HV/z0F5+y8R3Xd4VRAnW6pw8d8cOnfPSi8OK2cbFXuiEi3jEkm6h2obHx0Mf1iPV2UGWbY2t1HTxBcAGfGtFXNv2GUhu1DhweAjF0zJOnS4kvPvsZpVam+cA0z7x68zP+8g9/wJubkWm64O4+c317Qy8BFyvzeE2WHbs+8OZ2IR0rKQqhc8S05+zyijD23N/dMc2VmM5wncdLYFoWXKmUMuO9o+8T6owrGKLgpZFLZcpmtHdik+OqtinHYB7Qoo0Ug6Hp82ST5uAozfhs4PAVk5Y4RxNHaw7vFe9sMGFsD7dSeEyyJU0J0RNdZZuEWjDMkw88nBaUjnGynqdNtBWVijhd9Zv2LPrYENdMz9mE4Iwc9HD03B1OOBfYbDbc309EB13niGElQavgXKVJQdtCco2WK4pQxa3tqT/5+mYscGpoF1XFhfhWFvL4l9ZL82+npo/GdyvZzDSMftVwfuzVydupnH0cG7SuY/XH6SpKexQNPzaz1YB+Fkfo0VrX0FuoxfhZ2gJFC130FFH+6Kd3/P5PHnhz8Gwu3+H16xu6fuB4PCFipNM8Zeoys91tSD6wi40P3jnjyZOOLgIts8z3OJfx0RGTotVT6xnJgVMLSsMpPpxwYcfDNPDm4Hhv/z1+8bN7Pno5cn2YuX/5KZKPOHXkXGhtMTptdeAqKRS0NZblAOJJwyWuBSoz739ny91NYdddoW3Hk8sP8G7Dl28WXn7xhmcXiX//979kt33Ck7MTcyvcPEBMmb/ztz/mt3/7+0T3wB/9XmHSxOu7a/bnVzzcvubNi8/wTfnN3/4+v/+HP+H84owvv/wlv/dHXzL4gWdXju3VFc/ffY/tZos26PfKZhfokpCiR6r16JbmYIU89lroHOyT9WtVG7LKhlSVgpBXVI/zkZIby7ygArGzTbTrnuJUuLz6Nn3XUcYjr+/e4FDevPmE27sjmydnHEflcHtgai9YFHZnz2na87AITVbBqjoOh5m5Fi5kQZrS9YU9AS0zo0DqzgjDBSoToRSWw5FYlFImQm/ugUddKG8RW2rYfkzDKThaVcZcGIaB6DuiTyxZaTUYsJWKDxZv2PJkx1nn0AZNK2F9fh4zS804D/1mS60WfO2a+biby8QwkFtj2wVyhROWpWrKZcUOxQrNILTeOfDRZB2SiUGJfs/Hnz0wFUfqkwmk6z2XZzb4algGsMPCp1vN6yYtpv/sE6VWtD6Om/7k68+TyfBvAP8c8FJVf2t92/8S+B8Cr9Z3+5+r6r+3/t3/DPgXsT7g/1hV/29/5gInQhXz6pnTwI6Tbp1oYqcTa2qyevkkgIRVrLvy5tcbwK0TV2mmGSoiRGcUVW3W73Art947k56oeEMigU1KQ4/D6CESA42weuEsByKESMNTqPzOP/icV7cOSYGYlNubG3I2W0nyiS56ZoVRJ9xmx1Qd54PjyTDR1dfw4IjbyrMniW2XKdOJmDaMFE4Z8jJxue0RB6elcnuEV6/ADTtevAm8PkRa8Hx54zhe35LHz9H5Fa0sBlB0nhAdJc+05o2b561CTjGyTRtqKczFwIt/8A//Ae9/+CN2ZwO7qx3b/cDNaeLMNa7Oe97cjjx/fsZPP/45NUe64Smg/PyXnzHNR7747Be8evklP/3JL/no89e4ENlsBsQph/sHfvTt96goX7y44xc/+2Oj/W46Zg0Ev+fUFq4uLjhkoRs2tFNhuxeqeu5OcHdzZOtgEdhdbAgYnLRzlXfOItvOstSds6g/YV3kWkNLs8rEQdcl1HlO00xZJlJIDH1iKYWz8yu+/Pxjzq/g4XTNq7trkOfMxeN848mzK+5ff0SYZpb7W56/9wO+/PILfMzoMrPbbuh8oMyNPBXKfGBeTtB1NGlEoJxGaivETkj9Bg+UabRE90XR+hhY7QnemHRVhaXWx2kMGTuias2Mx4YMG8tIXZUIEKh17a+1gnNmqBcRzBjkTD/HOsxZTfbmvCjYvLKgFLwoPnQU8fiqJLWvcdsFG3g4668Z3tJBMQuk98ZXLFnJbWEsNlU9Vcf2IpF8Zgg9vfcEEcZ5QtX0jTahtRZRbW3NSqkI1qOt6yDwL7zAAf8m8K8Bf+M/9fb/rar+r/6T65T8U8B/C/hN4H3g/y4iP1IDq339JayseFvQvBNk1S/FmGzBa2vT2Pv1RfBm78K4Ue1xAGHr4dpj+2rNao8T2UfNnBlLbXjhzA3cEHABSR24iNO8Krojig1A8jLjmhm0bw4jP/35DbcPDXUD0Rl5txxmovdroG1HaJHmG8P+DICNzPz4g8aH55V3zjtidJRywnFi6DzxrAepnLUNpQbmYjaXOdsxYjjb8PTpBUriW+92fP6m8jf/37/L6y8PtOkWV+8hTyZy8R4fINcZJdNvEsPmjHHKxNAYp5HxdOLXf/3HfPzFSy4unrLrL9j0F2iIDJstb+5ObPdn+Ag/eG/LLz/5lPN4wbPn36UsD9wej3iJjKNwff2GNy8/4/rVLZ9+8RGlmtbv7s3EOBe22x0ffZT59OULliJcnm0R77l/cUuoIArPhi2ffPY5Z/snjLmyTJeo7Hnv/Q3Pz5QnXcf9oSI4ogpJKmOutCDcPEzQHOe7R1BqNqueWJtDgzX7XYZSZ3KrNIHdbmsVbV24eHrJdFxIwxN0NFjD0+ff4eH6mmm+pbU7pnyE2BOaQyVxmDNvjiNJD+CFN7e39D7w/J0PqVlpS6WXxDhbDGUUYxCmrq35vI3UC4SOPAmqibmuzg0yyWe2Xc80F6pmapM118DkT31K5LlS5tkGSN5OL62aTGYpJzoHYIuEYcCEUsyr7Zw3wnVRSskE73FeV1y5CYSdRnLxFBzJOVQmHObN/UrmY86gUmaQwtBbclwpdVUwdMzZoVV4dhXo+8kmqlUoLITOBlqycurq2g6iCbIed533dpLCHvD2p9Rwf57Qmf9QRL77Z73fev1V4N9S1Rn4hYj8FPhngb/9p/0jw1nZNKzScNWEgypiDVRxFO8IKwyPZkbjtiyIZJs5uPj2YyUf1zLbAHlGKPjq+CpuFZNGZ8Ew6z8MrifEZ8Tugilfo/WOuOY+FIQpz1Ad8zjTUubl9cQxJ8Z6IkimzhnXKkOXaK2y1IWmmawTFU9ZGtsYeTrMXIaZJ0PD6sCBOGzoO0/wBgCsxRKUaqngFKXSR7GYuRRxeWZpni8eJv7W3/05N28eCO1EYVxpEKugUqsJYFvBgYX23jWGzZ6zsy0P93fEEPijn/whu4tLVIR+d04TuHrnOU+fPuHy+Rn7sy0P9wvqhDn3fPbqBf/FHz/hj75wfP7JiZdffsJyc8OLz37J/qzn5v5L8/BWpUwTd7c3SBRyUl6+uiX0PcP2nLtDYdNdcr674Orqkt1+S+p2XF1dsd+fcX55wX4DQ8hcdY5ddGgfyX7m+g28fJNJWhh6B1HYpMqyVFyIdNF2OwsIsjZHriuxuZqEZNf3vHz9wOlw5NmzLbkI86L4GBnOt7y72fHyxYbr60+ZTw8sx89ZxhuyFovwc4GQBlpQ9mfnXPqeRRsZT8vC4RS5uX3NNl6wHwYW/YgQFTaJqo6uNTb9nrGOTPnAtt/h40AuCsWQ+opSFeY8IlIIWt+Ko0t55M2tLZymnKaRkDCsl2bDzLuA+ERpxWQltZLLTFTQXCAKkgIOZcVSkPNCDIJriZzBuQ71kERwqhSMeh1EKc4KDNFmfT+/YvmzUtR+1Wo+1ToXzs4TISw25EAgKLk2mGcTFzdWrJNh2zsnaGiIM59rc8JU29tF/uuu/zw9uH9JRP47wH8M/E9U9Qb4APg7v/I+n65v+88uaiJ/DfhrABdnA9IK8Ki4teQe56wP58TIoa1ZY/mxB+dNnftWJqBgVi7n0aYW8ILgXDIkushb0aiKIxCIklAq6iCEMy4vv0Xsznn5ulJYcNHK4FomluOR+ZjpY8eblw988VnkZi6UZUOIwvd/8JRPXt4zfpnx4ojqKDgWtRdm20OSSoqePkVURja7HhWHxIZGM5KrU9QZWMBFodQR1II/hq5H04ZjCXz5uvEPfudjrr+8wTER2omlHKllBqxy0daM0NqUnCuWxJ5xVD57eGX+yFVovQmRPnq2ZzueXj1HfOQ0j3DtOd6d+NEPP+DzT26IXeCXv6h08sAnL9/w9/+jn0L7ko6JF59+yel8QxC4CI67eWEqlvrUx4FSCrJUfHAMboCpsRkau50jxcr99RuedXv61HPx5Bn9JuGlUmrgo0+ueefZnv028t4u8nQj/NIf+ezFzO0XI5cXF7ihMUTHq4eME8f5EBhaZpMs8yLL433gqQjLWOk3ieTXCMom4CuqlSeXW15cP/DOu1ds+omPfvEpLWdcqQTfiCnSiZowerhgKwe2uz3HpfFwVA73me7iXciN7fZbjIcTZbljXl7SOUebG9t9h3OZulREBpZSCE4Yhi15Vg73J8Q3sjiWyaFECwDKxjesZc2S8xDELIhLK5wOMxBJsafvBoauxzXHWGacRJPX+PwWauF9MKG0Ki4EvARaXVbHj9ovp0gDKDZF9Qbu9E7wrTFns6k1NQJJjD0LibxMqDhOU6NVz/YsoK6QW8Gro5aMyEyUwsY7mhSaC5Sl4H214aus1h1xVFdo4m0gmJtRl7/m+osucP868K+sa8q/Avyvgf/B/z8fQFX/OvDXAT5471JlbZAZIolVsytr803emqlrsf6XrKGyiDNjrpiJHk20ao1Odab38iyr9n1d/BzWeyuLLaQh4l0ia0Bd4/7wAmEmpEhthVwmxsM9MUDYOnxy5LstSwaRwBCU9985p+sT97cHtpsnjNNIKxDTQK0jsoajZCqncaTkDu+FWidS72luDeRAKNpoqy2tiiK1EoO30Jcm1Em5uRv5g5+84vMvXiNtIVDI7QhtQaRQ8mxyCefQAvOc7YjeBO8d9w93vP/+B3zxxQt22z0pRe7vDsCGd5484e7hxDvf6dnu9pRZcBslOOXXfu0p2zd3/PQXd/zhL1/y9ALy+CUPb97w7LLnx7/1HU5j4/BwTS4T25Q5PRSkNSKe0+mBFCL7TUeSSj/0vH71BV98MfLu+9/lt/7SP82PfvMHfPfDd+mvzlAXONvYg7zfwibA/VQ5oZx1yrvv9Eh03Nx23D0Uujjw5gDz7Ymrqx15nrjaWjXfxa+8yKfFfh7jXDncnTgbBrqkxBjxzuAF4gXvem5vD1QdwJ0ZyLHd4mJiKZWQIotu0dIzL8J8WHA+0vcDrTmmuVEK3JYviTJRqSzZMb2+J/mB3AmpNbQIg+vBLTSfqWSqKv2QCM4z9D0vXt9SpViWSLWBhh1DGyHYDFRwbPuORZXxtJDLQgNazuZcwPBKWjOyzDbMU2VxFd+lNaHLFpQQPM4747w5hbbY/eSEKo2yNEvQUot8CsHCmJtaElgTR/OZUj3TqaMxMuwW6/mtRJXaCl2AzgnbLhF9IRdlLgshrE4N1wyCEQxP7kRYSsUXpfOO8o9bB6eqLx5/LyL/e+D/uv7xM+Bbv/KuH65v+9MvESzn244RiCOlSIiJZZ7twVTrE0Rnx89KIbjeUrOdW0kj1hIVSYjb0G0uqL5RpjdoOz3aGtcU+UCXBlwYcH5PiDt8t+HhNFPKA3W5JfhGK5U8nUjJLC2ui9weG5+8yRB2nGvm6TtbttvAH/7kE/YX73JzM7LZdjQPS7G+WanV4hBjxMnI/vwcH+8IAVDFF8t5mKYRccpmk5inQpkzMRhZoYogbWA8Ki9fH/n0sxuqCs7PLG1ckTWsrg9QrTS1QJXaLNdUJJBzQUT44sUL9hfn1KXy4Yff4cWXr3lzf09rjouzc1JQqAubvvHq+sT8e/DjHzzj5k3hnXfP+L3f+4w/+sM/Zr9reHfOdMzUh1sWKofFMR4rh7tbUufNJlQXtiHy/Pm7PH36nMNp5ouba0oR3rl6l9/6jX+KH/3ad3h6mTjev+Tv/oPfoZJ47/klH3znkhSv6Fxk30fuTpnXB4fvhM559hvl+ZMz7sYJVyLPn3Xc3I3cuEbJHu/cmoxmKPwxm/D7dGy0Fvjk85dsNgMpdpyfdwxXQgyOzeCZd1tevTpRdYd0T9BlZmwZrRUtlbHdsokD40nxY8P5hXEe6c/epTYl4Aji2HZPaW7HyEItjnFSXt03FoVlPvLscqC1hYXKXO5o9OC3hP4px7JwdpGZxhFtlnZWVam10erqwPaRJmver3f0wwYnnnleyEXJeWZZMqWaVzV4YZsSwQWiS8TujNN8xIXJ+HStosWqI+88Uo12410i1wXnhZwzTR0OQzN5J+SlUTVSscyHVgq7reJTIrcDj9h01cami/g2E936VLeM843eCxoNenkcRxDHnIuxArGeahc9eWnwp7T4/0ILnIi8p6pfrH/854F/tP7+3wH+jyLyv8GGDD8E/qM/3wc17VJrFanVegureFNEUB9o4ljUmGxe+pW4YLYRSzsPeL8luA3n+/c4e+cpxzzy5oWFecQoIEaB8C7ipCf4p1w++RDfWT9OFcZ7x/14xzzfQ2v00dFW9DTieBgDeXJEX9h3jq6DX3zyMUsbmG7vwFv242bbUR9GkjRIniYGtdkNO2KrDGJBO67r0aosy4KPiSaNeV4oUyaFSHOR0PWIJq5fmwzkF5+/5rQ0aAutLHhWThoe1WCZFFgwSs6zBVAj/z/q/izW0jQ7z8Seb/qHPZ05TsxDZWZlVlVmVlYVR1GiSFEiIEuw3IAtwDCMbsNA+6J94Ts3fOOrBvrKQF8ZFuCLNjy0pFbDMrs1UWJRnEQVWVNWzpkRGeOZz9njP36TL74/kuwGSxKahpG9A4HM2GfasWPv9a9vrfd9XnqbNmVqeAHnSiAnY4KAO195wMn5hpOrFa+9sk+pDNHCvJYEchbrnvl8iXWRtq44uThheTlnNp1xevSEnd19VrVnNiuYZj137+/wxz84wnUelaDyTLe22Nk7xIuCLNOMdc3W3j6/9qs/x83rt/n8RcMffu8nrFdPuHa4z7jc5f1/9QMYFbz++te5c+uQV+8ecOtWhsxGnHeCqrVID2Mse6WkthLrFDt7GhcikyzShohxkt5bjjaOSW44v6y4WjpCb9mbTsgyjXWR1coyLRS+hLLUBBFxfooLN3FNzmR7m3W1pKo2+G6Jrxesu09RIrlEpFYoI9nUDTrPE9a7XqPzBu+uyJVi3QliXrB0Al8JhJPIy5oi82xfnyGbBhstsVCI2R26+Tmxu0TpEVhNDB1aBoS0SJPhbEiGeefSZtEJpAERPGVmkOqlhVERfP4Fmry1kUwlOGxwXTr5WDl0a6Qtq4wJOiHFEISdZsN+OO2n/NhBqB8EyMT0632kbRp2t3O07okx0veJOEIIyOgpVE9mktbDRwhRoBBokRYgPjiEzGiHzJaUEhbBJ5eRztJC4qfd/l1kIv8v4FeAfSHEc+D/CPyKEOKd9JN4DPxvAGKM7wsh/h7wASn5+D/6t25Qh9tLQ/0gUkup6TJgZNqGJg9qWjIIIRlPduh6i/cdQnqE2WH/2m18lDT1BrQhepcG/16nuQOpNSYmT13ilPiEePEpH0mGgG27JAQ2KqGlY0rKCj5xstbzJSpopBG0fY9bBQKGyWSE2FT4GHA+oqVmUmZYI3HWpk7VOjoEm6bncEegtaHvLbk25FmBfblYaJKtShpBNioRUlPNK6L3LNYdJ2dNuhiI9ELsu/Rc1d4BCiGTcT66wbmBxBMSl0wG5BDNtt4sKcdb1FXNeLzFX/qLv8jVomNne5aCVXLJeFxyfr7Bth2PP2/5zs+8wgefPeHy/JI8VEyzglfv3cUZyWJxhdYS4Ts+/ewxTbPk2t4NOhkZjwuu3bjGbG8PIUuOX7ygyAt+9Ze+wy/93Hf43d//mE+fnvP40cdcXTzk+99f88t/8Ze498odHh4teHr0iGcnTzm+vM+bzSuYscfkmu2dCV3taauaQkXGM8FqzYBOEoxKBTh88AQMj14smOiM4Db0tqdvHav5mru3roEQPPz0jGpzwJ17e5S5oswMeZ4xnuwwr3uU0kzHY4p8g+pHXDxfp4AepYhG4bUCLYido20vycuAzNLSp/PJn+nFhFWTXKfWBUQQzBcdWxND7Wpm44JxmUG2RQyBncJwsdb0YoyKOa1dkMkek+nkiojQtRalBEVeUm02ROvIdEGS3wbKIifLc2L0GKNxzuPqjrpNYuPYNZRFnvJEsjylaCkgJjwUIr0XrAMRNcG5dGJSEhGSl9p5ydWqoap6tidj9g9LhOiTtUx5ShXpbUQoj4qRaWkQxITCFwoRFAFN6/4EFqqURrpA8D7VggDOpdNaiENC13/fAhdj/J//GXf/X/8Nn/+fAP/Jv+37/rdvaegrVWp1iQqV5QSROO5KCnRMRIhkPk4MK623MJlLgb0Rqs2auq+JocW5NVWXpcIoeowBpbPBxuKHFKEWZ0+5vOpRapwIqDaZgBN8UuBIx2aPpO8tfdcjQ8fOtqZzkqqOtF2PVoboO8pSJh9fncJ2s7ykcw0hOMbG4EykC47TdcstkZOJgBE6mZqDQ4qI8qnI6SxD5zkQsH2SeWTZiKtFz3ojICic7/HBERgGzlLTt0PRszaFZcsU3mOdR0ZS2EcMibLhI3v5mM1qQXQObyVOZIjwNnfu3OLZ+ZqDmyXT2S7zswUvnnzID38cKJXD9AEfBZ89ekFtI/uHt9na2uXs7DmuXxFcwGSSvFRMxruMpzMODm4z2T3g7GSOQPGrv/rrfOXeIUdPzvlvfuO3eXTxHB+vmI1K9g8e8O77n3G2sehihj0/ZWf3Gk3XcbY6Z1/u020sh2OF1wbbCWxvqS6vOLi9R/SB4DtOG8mk0EyMoAuOg1HOi6tIaTK6esNysaC3FnM2Z29nwqZp+PTJCaaU7M6m5IVia1ZChJ3pA548+gQTDXaxZr14hsgCWVZgfZ3S3aVBkmxomVLEbs1svIV3gXVt6bxjXE6SVs1D76FtNNKPcBvNfONRskEXkfFUsq4+wm2O2dneIpuOmC8uUKohBk9QAq0zhIQsG6WuTUnKcUkMCusUjU3QzVg7ypFJRA/bJVeQkuhyTNNbQi9wPlDmAhsUQQRE7MkzRZQWHyJt74lBEhxEr4gygNAIkTDvpxcbIpKbN6bkymHkS9F1wHsPDoSyQ7KXp28aRhNNOTI0m47gIe37k3TLi+RpLXKD7VNAj/dpCeRDEqv/DyA2UKTltEh4cqMzxuMZi80cEV0SEAqJRKCVIghB36yRosKYYRWOpakrlFFoIxCixtplWo8PSVlS6qSHkyIFcpCU2yGuEaEn+H4w5Q9ZqUEjPfgYmS88TeUwmaMsC/oosDEHGSiLjK6zEDzjSUnVdOSZxIdImef0nWesM0wUSJPT+xVRaWoX0NZTNTHRSTNFtD3RR6IwZOUUFwW26omxoJjsI/yUZxeXzKuOUiTIoe8FziWjsw8bfAzE6EhQKQFCE6NES4kMSXaASMsa23nmiwWT8Yi6ati/1nPz+h2uzi/Z2RthVUldRQ4OJXZHc/S9lkeff4Qxjt3dKY8en5JlW7z24AZCCqq6pptOaGrHfHHFqJiCT3afm7ducvP27ZQD8eI5rzy4z97uPutNz+nJCaOJ45XxAZt2ytGLE4ocHrz6BiJAe7VC52MavUK3DZ/86IjT7RU/9xde58Ui8fCi1oyyHD12LNYdmYBJKanblqaXXGrNLCvZHUUeP1tihUCEnq3JNj/64Am2j5ycXtDUDZOtCY8/f0F3sM/27pi8yDBSoY3i+o0DFpdHbKo1+ahgWS8xuWRvd4K1ns3GovSYKDwX8zNC57h7R7FaLelDi5A52mTsjsacXV7RdhWmKBCUeCFpu0TivbZ9l0UdibpkE8aYvsQsK/amI1osWhTYvsf6FFtolB6M8h5lFMFFjMkZGYHrOpSIdL1PkYSCIYBGo7Rhkk0gTAhO0jctPutQqkMEQVtVZLlIYdjSYH1aZ4BHWKi6jqp3rJvIbFJSZBGtPMF39D6iVTo+f0EaQybAAALnBbJNhdBkoIWh6nzi/AVH8BJIF/40XEmJYlILCA6pJMJ9ya1aYvB9xjgwXUVguZ6ngaYaADkiCQYJHqVAxZfJPKntDghMppKdxZMAgtES/PD9ybDOIaVGiCSSFEIiQpGuArInkmxZgRboCd6n+DovaRqL1CVNsyYzOWWeQp8DBq0LemvJpEG4wEjn6AJAoQ3IiaHpNmQSEI5RafCup3WaiYKszJAZdLbGRE+UiqwcY2NaUigpyNUIXUz59GHFwycLvIuIzNE2DUKMBktOl6QgGrwN6cUzhPc4lwqeHiCgWmh2tnaYTPa4vJrjvGdcTrl+fZ9ATtQZP/7xR9y48xWaLhGCt2YZNhOUsUTToNggXUQKy+OPP+Ta7Zusq4bVaolSnun2jK1ygpYyCYWLgrrt+PTjj5mOCvZ3d7DO0daW1gfuPriBykYcnc/xoScvchZ1y+HOLjdfucOzkxWbtuLF0UPuv/oN7r9ynavFmv3ru4S2Y38rAT8zrTlfdGwkuNZwsQEjHeOxIRQVu5OMW7enfPyo497hFj/+4CmT6QF1W+O6DYv5FZNqzeUZKYxZHpLnhnxAaDdNh5AZ2zs36OorbtzaZzn/HB8sznomoxG9iywWa3a29unaDefzIySe7WKIp3QNq3o1eFAjiEDEIFVOZtJ8bLNaoFRBtZ5TZAW9i6zaDfONY3d3Fx0bYrAIHaj7lkyWWCdxMV1QMq1RCkYqLfHatsWHQJAapTOE1GhpKLIC6yTXr3+FcXGDi/M1Tb9itXpEDAuiU2y6BmlyUsg0CJkkUM7nRCkwmSBzPdOxQEaLiB6ZZ/R2OF34hKQKTmCjpo+gomeSC8rC0DZrIolMYpQi+C6hyYTB2p6o0kVZSIlC4Wyf4griS1bgn337UhS45BtNrWyKHHMIKcm0SRBModAy5R9KldDKSiWAXlQCh8RkJUGEgRhhiMKjVMbLPEofPEIm7pZ42QKHSJR9CumVyaPo6QmuS5uZmD6/7TsQ6YU4KSWZ6ZmNDDZGTueK3ksyLTBCY7uKohyjtBnEmD3jXIHI8f0GLT3CB7bHhunIgHTpvhgGc78mRoUXcgj0NUQEZAVX65w/+sHn+E5ggLpeEqNEyIzee6q6SbpAku5NybRskDJZdXprsSFQZgW2T3OVYlTyYPeAp0+fcGN7xuXVJa++/ipBBD5472N2tg/pO0cUGc4V5JNDPnv2MXb1DE1PF6CcFDjb8uTpczSR9dUl9+7fYO0cWT5id28HnY+RZszxyQW2d8hMs256rjZLDvb32R4doKdTPv3kGTEafvmXf4W6DZxcrTlft3BZ8er9OyyWNSL3zA52qOqGvfEu63XDwd6MYqTJ8sDp2YI836Lpa7quZX2xYGe7pKrOuP7GK8zbyMU80HdrfvBBQyYytrYjl5ctq4Wl2bQsrs7Y29/iYj5mXGpm0zG9yShyk/R0fWQ6PWQy2sPZmuXqDJEnqU/f14zKjLzJWW/aNOaQBTk9JlqidiA908xTFIoYc1ZtS+cC9SYN+pFjsAJ6h3MaTES4Fucd09EOWb7HevkUrSSy12lORotEoXSJEoloIgEZPFpEitwk33WWoVTyy4KiGF1jLKe0VqOyisObUy4uBa3dwrsNigmd1fjQoHCE2NN3JcfnnpPzFaNCcePalN1JJLgGBCiR8B9akhwlUSeAwADu1AjGJrJbevre4YXEWU8M4KNDkEz2IVjybEQUkRD7QdeZFg1aatrefoFQ+7NuX4oCl7jqyef5kuGVnAgyURGkRAif2mKhB0qvQog8zRBMUnNLSTJTxzQMTQbiVDhREH1M/js/rBfC4LULKXU8eJt8bzEOMYWeaEEGxyg3aK1QylEaDc7S2Tk39vZYt0m4Z/uOstCgHChD01hyVVA3HXmuUdmU4BdMisDdbShVPYR8kBh1QeODQg/dbBSSLCsw2YiuH/PjhxU/+WydFO0DJSRGxaYVuCiQeoRrUzal1glbY/sOlMZ2CS2tlKbrkhVntdpw7bpE6oKdvZss1muEUizmc0YyJwLPH3/EN77+Jut1RZCWd27miOWYR3ZMvbDkRYY3klAogrW0mxVjI3jnza/x+PMLnIdxOaXvHbb1BOu4fu2A7d0D9g5vELVke79gVVmefHbGfDPnzTffophAVhtuvPpVLi4dVbug9jVfff0Bm3VN30rKsaJvK1yvqeZL9qYPGBvDa7d2+Oipo5UF2/sKqyXHR2tk47i7aLl9o8Tv93RXPZ+cXJAZgW8bblzbZ1qU/OiPz7GuY7NccSwFW5lK3cb1Q3rbAomAS5T0fWC5OsfkGasqxxQZRE3VtQRVYlXP7u5tzk4uEapFGosgZzbZZn71jExnKdnderQa09tkF5TC4vqO0oDUEmVACg/igDe+9ku8OD7CsSHGgugbcgW51igpCGTImCUvqgiJFKwk0ugkdZJyCFkHoQp2dm8yntzm0aPnNPUlp/ZT6rojkLqvoDRCG0KXRLWdk8w3irYr2duSbM0Us1mO1i3BGdquSYHX3pNnaSloPLgYkFqQ6+Q3LyRkmWS9dika0RR46wk+NSoIkCamuXLvkwddCkRMOGvnU+frv/TI8pCeOKUNYvDEpWR78UXwjBgY80pn6XhKslyJAaMkIdmSUpVL5mqfdGBKSVTUQ4p2DwOoEpEEqJIwUGTjF51elHFg3UeU1khjQEoyM0EYgwg9Yr1gZBqUcmQmYZv7LrK7f5PWZzx/cY5RAh8EOjhUXHPtwLAzLclVBT6ldAXviEiUyBAiQ2qBdT2myBFqhA05Z0vD9/74CX2zRPgGQU3XgwsFMpuipaSanydogA9IGembDiEiNgZcdGQDCDE5PyST8RZ9bXnj9Vd4HM+pNnMiJXfvv0I+2saMJjz8/DNu3loyuX6X9brCEwjGMN3dJZOaqGE0HfPK3Zt88ONP0JlCugoVISsmbE+2Uj6tcuSjnPE4pygmjMZbmNzwzW9/jfV6xR9+/5iHn56xO52S55Jf+IU3kTpjewKntuC3fvczdHWB6leMxJimtYhoWdc16DHRap692HD31h513ZLlsDmvuLk35dbBiM8+OWJkRpxcXTLd3uHj98/4/k8u0dkaFSIiXuNf/ev3aJuaTEt2pwcoI7Au5UjsHxqavmU2mVBVa6QCpTLqqiU3EpNZNk1FYW4QRcnl5QahCpTJiWRIaWhdjzQTjBmzWEUQu0iZs65qjCoSciqTKCXxtsdkHVGBUPkQ6G145+2fAybUVYXJ0uuli9DYFqQiFxkEg/UdRkj8kNUgRZY26ELRNYmmnOVjMhG4WlyyXDn67pIia1hsjjAqw3tFiAbrs5REFzqWm8ByJQix4dZNz3isk+2NHms9gkCuc0CkPNbQgohILZFBAx6hkuzEObhcdDQ+sfuMjoOES3xBZlbKJIKaSBmvziWCsxQeZGJE/g+CB2eyInVrxsAwi3sZJCPkkI4lJEpoFBERepROWGYZwSiTVP7e4WJHRKAzgwypg3M+vSGEjCiZQUxDTEKKsEv5qelYKKNIuHSAmOLcXgpolYAiy1gvNoQoCDalEE2KZC3JtUTEFaNsxuFewWK5JNdQZIpJJtgrW4SCXgq0LjDO0sWIzMYU+RbE1IqDwnuH7dfM65Z/8s8/ZXFyjomn6JhY/crMQI3ofI51FlQJribLDV3TIAaWf5o9JgdDfDl7FNB3a0bldfZ2C27d/zYXF2vGoxJrO9anT7h29wFvf+s7PL603J3U+F6wrjQHu1uUYc5oJ+Oj51vcu3mDq8uae3duoWJAh4qDa4fMuzl9D23TMhrnjKY5MY6QasRq03Bne4t717dZTCW/+HOv8j/569/mlVfuce8WKCFYtZH5VcUdA9ezDdLsYGk5Pjvj3u1DXn1wjZOTM77y6i2eHfVc1B3yqubmtYJ6Nef8bM7BzHHn9h5704KPHlXUHcyXSwiedX3MNGi61vKsqXEhslqd09RL7t55la1yD4RltalYrlvaLo0uum6dUEBCEETP5eWCcSnJZYbsqnQy8AHb98xmN/A2sLu/R7UZszXdZVOv+corr2K0ZjWv6E8/x7qaKGGURYLtKHNF71PgTF5IRIgIm1FtKk5OT4ihxsc1ShU426BFRt8HgohokzoknMQF8K1C20jTNUO0pMFZaPqWMoeufw7hCIFjPW8TaUdDpCaQMOkipuH/xXLD9pZkojNMsPRVn/IfAkPXFSHqhB03YogQSIzxKCVSBrQIeJukV9YnenCQEd/3wyInOS5SWp7GeSB4RIhJATDAS5Hi36iBgy9LgWOIP9PD0exlJmMMKJVU6C+LXvRJT2a0QBIJweEjRBKmPHjw1iKkxMaEeBGRAYgJkOB+CamcCKMuuqF4RURMuQgJm17D8DkMWhtnLcvLZfqj0ghlkiWMlIgklEGoHiEqtmaSTFmMiihlka7DBIeHgVAScAFUNqLrBdoEvKvQUpLrKV3sODpr+N4fL5lf9AgCMpZ0YU0UMWVZRoFSBqkzmrpGmzG9XROCIDclfb9JTgbvEWXKnEjdR6IwPHvxDP7wD3jrnV/nm996k88fP6dxgaAksxGMixmTrcDd22OOnizQucBWESfGTGf7zEYnlMWY0UxgxpJCSqbjgun+Pt/cvcV6Fbg4PUOogDYR6yV101FtNjx+UvPxRyO+9c6r7G+X3L6zzUiJRKqgYeM0z59WfPjxCddmgihqHh/PuVqcsr8DdV3grca6jvGsIB8XnJyvkGGGkoY8FxyfbpiMpxzszPiUJYurjsvTDYu5ZWs8RomOZdPx9JPPGOcyFReZcbg7Y7y9z8XFOYiI95bFvIHQM53m2M5hsoxVtSGogi5olAhUDup6DaoAUiZr33XEYJiU19msWibTGev1HCEk60WHFyMmezus1pcI32FjDyqlZ02yAtfXyNgSxIZPHv1r0CWZNhjtycQGaTvybJs+JBhl53sCIenjfARv6VxM1ikk0km0NIQA9aZJiKdIGubjkEpRBEkMkq3piLbveHF2hrUtt65lTHWLMolH17aeth9yIgTElJaQ5tceCqHQUhBUkkF579AqRRB6JNbZtBD0nkxljPKcpm9h0KlaF+h7Byk+JcFAB9WFD0kdEb/0yHKRcEfROWDwiQ7iRec8IUi0GIi9MuFmQgdK+WQpEckoraSCMMgjIkgPQTiIoFWOUjlRJAN+DA7v+5c/fujWPELkSLXNZHrAZvMcrR1SGkLylqT80C5tNr2MxNjiXUpLknoI/AgNio4YLDrWjOQoPU5l6JVCiEju09HUG4lWYPue6GoInqgUXQg8O+v5zX91wvwsqc2j7pM3VWlwKdZOFyWoPBUlU2D7DlsLxiYj+A58EpIqnQAGJs+RUuK8R4rIqMxxrmEyjpwen7JaW9atYDbb4vi44tXXSl6cL/nhH32CQfLV+9uM8glHAa7qhum4ZFyOaBtHoSVlGShMwe50xr2v3OLJ5xfkwtL2PZOtEofi5HKF0hrhOj758HMWFw17N7axXccrt3dppcY7RV9bvnK34I1X3+KTx8f8o9/4PT766FOshanscFXDvbuvsbxcs7OTs5U5Rqbn8WfHOJEsPBfnp2jfkk/2yYqe1dIy3dqmiDUmFHhfc3TZc/TijJGx7O9vc/fWHerNkt2dLSZFZLVs2Oy1zCYj2rYnhJ6yzFIAsXMIFaibDZlJy7JJNqJtN+hMoYVh1a1BBG7dnPHJpy8wfkKzkkwm21Tdhq2dg3TqiAKjBDrzGBMI3mL7BUZLssJAMKiuRhcbfB+wLVgvERicypjtTrk8P8H1a7RIpI2XqVupQkTAIFWWABJDd+a8H+CvKeDaR43tBZCzvoC+diAiBzuGWdEOIxKJIMdHkYjbMcUJRK/TSYiI9x4nE09OSYUWCh9yeheQQaaT07CQyLTBGEln20HAGyFEXG8RIuH8XVBDnKYgkJqSBK796aXlS1HgUoeVztKRHknqyHyIKJkWDyEpgNPHhCCQQjpAIlUaaDonUIN1S8ZAVGlAixxw4yRyMDF56ngJ+pNywJ6n6MLxZJYKQWOI0eOcRYkMkxU436CURsiQBMgIXEjFCiERcY3CIuIY4VTCQNFD1DgBqAzfdeB78lFJVApre3INBo+NAu8Nx4uGf/mHxzw7ylExoESHyjSyz1KUq4/k+Yh12zMaldi+I4REqTX5DI9DuJ7W+gGiolNgR0hG5VE5YjaZYrIcHzR/8Lv/HLKCv/xrf51Rl4OU6GLE0dExo2LG+arH6siTZ5r5ckmWJSlDmU3Z2iq5vFhjVMTInPF4QvCC9cKzs79NOZnx7OkzdnZm3Lx/k+XGcXp8xvHTJ8wvjunaCm0e8EcnFzzc3uXgxoRvvH2L3V2DNob/93c/YbVq+dGnzwmt5eLkBdXiIVvTKf13OmYHe7zznRG9n1JZxQ/f/wnBOqrVc976xtd58uSCu/fgjVtT3j17zogR2WyMlJH93evUYcPHH+ZUmyV6qcizU67v77JZnrG/f42LeaBpO25c3yfTM/quxtqOEB1lbgguDA2bRSrB7tYdzi6eMJ6WVJsKrSU6z1jWV+QTjVSG3d07rNdX5IUgLwJXx5eUBkK3IdAORJiQKP4Emjbhvr0NKJleL1qOcS6jKHeZ7dxgvpij5AQlI85tUPql6FhRlAVNk+ASWV4kR0y7wEiDi8mZIL1Po4xcUTeOqg8EMgyGUitsX1FHxajYoWl6OudAZ8n25TtUTIs45yJ979CZxKNQAqzvwQuCS7N07/nC3qVixGQpbjDp61IjQ3iJNpNIbQjOJctk8IO07GXy3p/DqvX/j1skWaAEyZpBDEM5iildC0UI4ov0nBjkoFJM6+IYUuKQAPCgVdrcgMc5Ev8LQfQkXpXvEXLowkJEYdLGSRqCgFV9hGwvIDrAJZM2IZnXXU8KqU62L+diSqfXJdEl60iKZwsI6VI6l8qTo0Bpok8rcnJNMBqlEzAg9DU+aJA5q6rn008vOTrW+FCgTU8XFNF3aJkjc4PKU0bDwc4+RuVs1mt8VyOUBJXRdgrccCSJER2hUAbberTK2N7awznPZPsG61VFnikOb9zk3Xff48H915jO9jjYu05Uiuenp+wdzKjqJU9eXKbZ0pamyDTVoqK3DlMqzs6WyGXPjbjiO995wMmlRxdjQlPxymuvcnZ8AiFwsD+iqUaI24cYVfP40Skff/gRo1FJW1t2D7awVlFbS3Xl+H/+F98n4wrfLFherlhcfka9kIS9Lb7//Yqvv/WzdF//Bh9ebTg+XrG8nHP2/DPu39nj8nzOYtPQqxbX9hzc2MH6Gu9Kbl3ToDXLjUXmOaLLKcqctmlQQrJcNpQzxxtff8Dqco7RkulswmYNUpaslhcpC0IlwKOUHq2nlOUeQp3TWp9i/IZTxXJxQZFLZuNd3vjKG/z2d7/LbC+yunzCtDBkytMO/Le+F2idE6JDqRwBdEFjRYn0E/LCEHtPlpVMJltsrs6wXUNwLSLaFD4TSIAGbXDWfBHAI4DgAoXeoutIWadBkckCHy125emqDlOWjKcggkURiZSs+0jlPBkKLQ29Bx/aL9wKqdcKKT2uD4lKbAYfOAEhU+yfSClTZLkm05qm7emcpB8yTrUYBMEiUXicDVgfid5jZBjsm6kYfumXDOlhph4reo/S6S8pBIMLITLgO3kZBOxCKnBySNmSKkvRfIJhayRQIUXTiRgJvkdKhxCQKQEYGBhxYngEAQnRo4UAEtYlAZgFiD7ZomI/SExswr4onQitegjdkJo+NBgJ4JMP1KSrmo6K0DkyrYgi4jpLW6W070xkOJfROcnJWc3Dzys2dUkfA7kG3zt8HxBRkRUFXRPY2tmnLEpWi4Z13SOyHI2hrVcIlydB9CigvcPblhg023v7tG3PwbVdTk5O2d2ZQvRU9YpHDz/m2uEditwyHkmmW2lLe3J6wtXZnFGZ5mvzbsHzxyvu3b7G7u6E9WZB9BrbtayW57SbDf+4/h3+vf/pX+XJWYUZayQNd+7d4OT5MfdfuwsRTo7P2JmOMDrSt2u2JxO0dCil+fD9hxzuz/itf/khDz/8CdpecniwzfjaNj5+hUxu6DYb1udLunZJc/U5q2XJ8YtTtrbG/Pj7Z4TuFCUUj5+f4+wB3nkmRUndWpxq2bTbvLKvuTk1fG++IHpLaTIW8yXzZYWqOnavH9C0cLB/iK06fJZx8+Y+602dTgP+EqJDiIBRmrycsKwuKYoxfXtJoEFqwfb2DKM9fd8x253x9PFz9vfvsG4fIoViPDLI2FKIpO6vRYn3AincEAhjEjJoVCCA3kuMDIxn21RdS9evUNERY48nuYFS+pXAA1mep6Qx21I3FUpMeX5mMXpCryWdjejQI2LLtAxMtiVCWoqsRFLiugajQCuL7QNOGlyQSJkyVKXUEEVacIRAQFKYEts3WNcn2VeMiYCCAuETfURpmqr/AnUeRApzFhKIMcWuhpgeu3NI4YfM42Qr+8KR8VNuX4oCF4mEaInOoVRABMVLpHIkbVuMMl8EiLys3EJ4YnSIKBBCpzzPmDynUkSiF3hvB1kJQzs7RAULvuBeCaVSLOAQAv0yUzUwBODGZOny3hJd8qgqrRExHZFDtPRtTXA2zRtUogvHkIq2bdvUtlc1mR5BUdJ3Fc73qGyEjAaEou0ci6rixcmSqo+YyYj1CkYiR4lLQgiUozG1teT5lMl4xrqpqJ3D6wIlDc16iQ8aLWZAh1AeqAjO0fQ9dw72aDrP1aLC+4C1G0xWUpQ7XF5e0LUt5+drVqtjvFAcXL9PcJ4njz/h8Po25fYe3ge8bVjOl/SjGV3fUa1aRBScHJ3w2XLF871djIL/xb//N/nwiafZZMyrS2xree/HHyG0pjSKk6NjumZN322wdc3Z5YgPHj5GasHdu3d5971H7O9k1OuSvm+5eXOX7f1v8eLkGc5ccvvOPZabjHc/OSKbHuJdxePPP6MwipPTc7rmh9y59yrziyXC5Dx8+CihhPIZ2w9uMBuNefL4jPt3Djl++oTClETWzFdryjxnd2uLZllTzxe88do92s6yWS2ZTaeELlBVGWWxjdcRZ9sEaVA9hRAIH3HBo8yMcbmPazdoGbhaPKVfwf0HX2f1cWSyrbBW0zdb6OgwuUSYLnHXKJGipCimSOvobUjjk2Fc09cVzvYIFQcft0CrHK108mu7iPAW6+YIbSBqNiuNUFPq0OFakMYSfeRyccUk79mfjcjztKggtPgYQZZJZhJbyswThKTrh+g+EcmMJtiEF5PS4HuPVylIxQdJ5z0aiZApN1VKsCERiY3ICaJDi4Rcsj5QW4siJYAZmYZW0SRhshCp2CmZ9K6phP/Zty9HgYsRgU/+sj+F532ZnPUyuTy8jAYkRaalLWsi/sbQJtEsyUcakAg1JPqQfKfEdJxNqVv+i++PEIntJVOgs4g2odGRvJwKRJ+48AqZ/lGDJHqS+wBBsggPR1eZ4fuYiiEBLz0+ukRXHU/A5Njeko3GhJg2sLZPtAtTZBSZRMWKd772Bj96b4ltusTDU7BY1xSTbbJsRtuHRGAwSZXetzUu9OkxSYUhQ8WGGDVIzWxrn63ZLvaqZbFc0dYdR8enZMWMGzcOOLh+gydPn/LixSnf+U7qsk5Pz5nujHn6IrBqNyyftRRZTrepkNtj5vNLorPMFwsuFnPq7pzVJnU1v//7n1DX/5i/+e/9Ijs71zh+MqKvN1ycnlFONbkRNFXLZrPg6vyE4Ho8kiwruXb9Fk/6moOZ5lytUCPJK3du8+D+AybTLT757AG/8zv/lD7UTEYz3njrVf7g93/E+dEph3sFj94/wbqKuWsJQfP1d97malUzX6wAwXTc49o1lT3g4aMnbE0VJi9wIUmWdg/2cLXl+OgFB3s7ZEWBFZGma5nKbZSArWlJ349xdoQULc73dK0FBUolPqHwGeNsj53JXS5OPkZIT9evyHLF8dH3yIRH+hKTRToLewc/y/npCZvqMdkksRCtzxAuYl2f8FneghRkykDfoV2HIxKlQiqBCxHR+aQwyLLkBQ4C3fZMbcTMe+q6Y3eyzSmSqlrhvcVEy85WhpSOl/Nu11cEFFk+JjpJDJZiZLG2TwSeYUZmbYcWCq0zbA9KksZGCghyGNsIQvBonRYM3ivwIJUl0wrvU+pZJJFLpExzNhECtncIdFpQDHGeRIsWkai+5FvU1E0FpEoPRw3IcUFqd5V+CXJkEPdCSpKNvJT5JmF2KnhEh1BqmN29zMlMHDmpBlJwlMTg0VoPBUEkyoIUiQtHkl8YPcb5gJaS4B3WNkThCMnkitYCT3q8SV8XaOokzYjWgQQvJTIbYcwEM55Sdx15MUJJibctSjhkrmh7yaaxdM0lzeaK9378iKYp0SrQ9i2+7ymn2zTeY4JDKk3bdzSdpetbnGtRiuSnFY5IGv4iJGWxBUGzs7ND1S2o+pSXOV864vycUZGzu/cN7t9/lara8P77P+HGzQNm+7fRoy3K0Yje9VTzS3KlWS0uybUlqoJ6vqLqr7g4W3L0oqLerFhu1lS2pe0drff82q9/G2LGarMGPB/++FPaugYRWVYrfHRUmyU+epRQ9LbFoZEC7r3yBts7U779tdd59uSMH/7g9xHZPtsHt1jXKx6UeyyPVuS2Y3N+xaOPTlFasalrJI7l/JyP3nuX/es3uby6YH/vEGs9XnqeHh2xrGrqxRGTMkcpjzEGoUvIM+ZVz2zaE6MjU5FeJhnTcrmiyA1SNbTNguhXKOnJygwXAt71GK1wvmO2VdD1azb1GpNFJtNbtN0G506YzkZEoTCmZzbLONg/5OTFJaNymyJP6VKLVU9rV5hcobXBDwlzLnhC7JO1UWQYU6DpUS6C7fAyQ3pJHhVZFOyGwPTzY5g7iuv3+C+PntGMMvLCsrWjKWTPbOxRKhIx6GwbIwR9v0GJNGqJscT2JJlW7rA+0FsPQtMTCa5Pb2j1Ukc6gB+8IyqJwJFpiZUC68TgSdXpuKmSSF1piQgWrdMJy3tJ0ArbRwJieN+mDlkpkZYdP+X2pShwyVIlEEqm6IyQiJ34NKwUIundpDRDkUtdmhYmDdCVQQ34ciFSGk/0id8OLxO2FHHoyMJLBFOueZmhmlTROq29Rdp0ZcUopQ5JQe8dwfZDd5iKrDHZwMdqU6GVJvnqnEWpQeioM/K8xGjDbLRL2/QQAlEE+rYnU5q6b1kuF/R1xOsRZamQ0rKu1ok+0tUIH9EmJ6LIcvOFZtBaS9dWBNcgcOnYLQXR91hfUeLJlBy4+oInj59ycrFAZrC/c8DV1YrpeEq9WUHoWK5a9g5usLhY8fTJE965to+MJYXJyMZjmsWa+fkJLjh+8v4x2ki6aoOSDatVg3dLpG7wTrJYnnFwbYtHDyXhv2745jtfo64uAUdRKi7Prwh41ps5i/MTou2QWUZZTOhcIB/lHOxfQ6qCi7Oa33z6O9SLS5SRyFHOnbs3CWLG9u6UT957j4ujT/jGG3fZPpe8995HX1jerEtBPNX8nFwqNqs5ewe7XK1htTom2gVlni50gQwpPK/cu8VqZfG+p249udJ0mzWHB7vE6BiNR6yXl/T1nOAailwiJNh+NRCoLcG3SBVpm2dJckTD/dvfpG4jeTahbiqkbMjygLWK8XjKh5/9AD3O6Lue4CKTcszsxjXOL88QsqUsY7LUBUMkJ4gIuiQ3JUIG6toRvCPoQEZkt49sL1oOW0V/tWQcxrznaz49u+QSzdbEMJs6DnZAOA/aJYuUNonaazSZ8uDWIHSycAdJdA4telACgcJ6hfVpiRC8J8SUWpbCfkJ6D8rUVCShlsJkgiiTFIyQvk5nObHvvtiMJvG+wLk0S89EQBkSSUQmXPuX3os6uFCTOlyC0n+CNQox5RRIqRMJJA7bUIZYQJHWxlKJYVMp00yOP0m1Tz5XhmNpSlNK8YEkSukAohRSkgmNGuIF26YaBL4Bgk0FJDhEEAMZNZ39lUwF2DmbfLPapFmfFOgiT/mjKBZnZ0lPJwW9sGhhePb0KA1MA0wnh6y7Crxga1awqnokka7rKTKBcw2FmuIxKWvT26SYb7tUNKMHmaXinyz3iCC5du0al/NTur5is5kzHuUsF2vO6iu+/XPf4smzM6aznE8+ecR0Z4/T0xe8/uo7PHnyIY+fPOVrbx2ispx11eIRdLZlvVmwqitiaPGuJfQ1tnMob3EuIZ8EHcdPOpbnLzg9eswnH/+YcjRiZ++AIB0eT6YC9foK3zcokYSqV6sVWgXKLjHIxPk8wUvbDcJHIppV16HyhoODjE+aC65efIZyNT88esjXvvUz3L5xi88ef040Dq0cm+qMri2Zbe0yv7rgnW894IOPn/H4s0+QtsYJxY27h3TeMpmWPHn4OYUxvPLaA+p2g1CSq8tzjIls787YrC+w/ZqmXjAqMqRSdJ0lhAYpBERH9B2myLman6FkYDrbYr26JETD1s4ebdUTacHXjLJ91psN+wdTeqc4PzWobIbMpjT1BiM7okhzXqNAG41yBisFeb4HzuKqKzLvscKxZSPbVeDapSN+fkV54yZrU/JwXjE3gmZbMjaOw2uGooxo1SIyM0i1LPgGFduBki2QOuJsTaYMWebJFWgRcCHSegld6vqcCwSfMoqVlOk4GiyRVAC9A6JHDZnGkPIWIikDQuAo5J9EKUohSSjNpEONwwLCewhJ3zLM6P7s25eiwMX0FkcJg7cBaZInVUqF0clgK9GDBAOSPigF1Aylazi2DnA94ROBVBnkMI4VX/wGNWx8hFBfSE+kACVSsYLUhYXhK4kR27cQPdEHlNEwiBGTFzah1r2PA1CToatUCBcRsWfTV3gfEy3ES0wmOb1ccrZ2FNl2OkrriI2Rq8vActlRNVCKKeMS+rZhPFaURc7ReYXOi3Q8bRt674lCoXROGs9IpuMZk7xkdX7Ei/MFKhuRycj56RN8zPmlv/hXmK9WfPTwBddv3kYCt64Z2r4hyzTr9Rn5aIz1GU3r8BgQKVKvGE+5vDwm+Ja+rfCxJfZp2ydJOaguWrouEnwkOpnE2nmkc03qSHVOZy1X63my9QAhSqK1yeojIlXV0NqI9JoiM+SFJt8uOb2qufXgAcfPF1ycPOO8WyKjo22WjPf3+MH7H3H75lfY3d9jcbkgy2YEJ6m7Dp11tLXjR9//lJsPvsbRyQlSlbzx+l1EfhPpKzLds2k6ZqMxs6lhunWIEp66uaTvx1xe1LTtAu8asjxDKUG7mRN8gj3GQVcZZcT2c+gdyBJkRBnBJDPY9hwtaiQWLTO2ZjcwRU3nlvi25+6t18izHbyHy4vvYbQjKwxNDSGMGI1uoFoF2hPimBDWrGXPRAnutIrt84r86ZJRr1nmI348v+JypMgf7LI9iRQmUI0zIg1SJsiEV6BUOhG5LgltQ9+ic0MfLCJ2KBSh79Ejg5YOo1JEY9d2iJjC2IXWxCAggnMhgVlDIom8zGqVuSTgwXqM1BAcMTqMhBB7dGIyDe+ZhDl33qG0TqBLAVG9nKl/yXVwgoR0wSZ0edpeZmhjCFiUSvQDKUAKQ8Al8W6AoMRQ0Hyij6CSTGSI3Qtf9HqADAgp8YEEtUzNIXmu0xFZSHyMWO9SFjQpNNf17gvQnhr49qlXH5jxMRBdIuVqrXFIVEqTgeho+x4fIghFlEms2VWW9TpQtQUXi8i169f58NFTfLthUylWa4eKmjJPAvQQBeuN5Wx5RNATCpEAj0EJ3MulyyCdiURWm56u6VHSUGQzvDL0vkFl2+xOdnjvg4955fWv05084cnnn/KLf+EvcnV+QW7gwf37HJ8sKcsJKivIdeTm4T6Pn5+DNgSpyIxhs07DZinUAAyI9N6llY7WhJBU7HW95PqNQ2y3IfQ125M9okgatFAU+K1Zws+7AAK0iiA82mTMJmNWq7Q1fuvNt3j/ow/46qv32D/QXJvso+WIzbrn8Ytjisk+r/3MOxy/+JyPP3ufST5mXEz5H/+Nv8Yf/fF7LOuK/YObVG3k8ydPyScT3n77bT768GOizri2e4P9G/u0dsnz558gdKDreybbE2K/IisCIm6IURN8ixZJAO6dS+FHSmOyMd5aYmgRIXVxuVKEriZESy1qVg6MiIxKAWh6W+O1I9c51UXPaFTQ95FrB9t8+O6PEGEDUZPpGT4PhD6JfqUs2ZpOMHKPp4//mF0nuLkK7D7f4M+XaDLOcHxuKvrDLUbX9nG5plU91rfImHydIiaOopIi9UqRwYOaErZkFIxUPpjfE4y1sp5Mm9QYaM3+3pS67ZivLC4my6L3Ic3gRDLRE1OcJkanyEAhyGRAqoh1w88PKXvXeYUIie3ofUBIQZ4XSAneC3wMWJtSygYN2Z95+3fJZLhDSrU/HL7T34kx/mdCiF3g7wL3SbkMfzvGOBdpNfmfAf8joAb+gxjjD/6tFW5oPZMXNQ0qQ8gScz4kGqkSZtiupm5MSZlmbUoNZN5kvQpBDJ2aJMqIFwGp8zTPQyQK8HCWF0SctexubxNiZL6pCDEdd5MJX5DpbCCdpwKJSkEcMipCyBA+0UfiYD2RUqbFkZC4PmBt+gcWKmNddYBms24wasLd27eIjLEh4vSa4wqCXVOWO4lbLyKrzZq+A8E4STtw4CwhRHQ2JiscXd8M0vBIjA4vDW1wZELhO890dxcdPX1To8yIv/Xrf5Hf/oN3ERjKcszZ6RnXdnc5Pz3m3Xc/oCxnbG8X7EwydicF882Kg1mGqLZ4eP6Cre19Vos5Ksp0tDAhyQZEBjKgZICQRJxaSl68eIwPgrIsqapTiDPK8R7jscJZx82bt3nx/IjVKnVjeRExWnD/3jVOL1YcHu6yuHrGWGfc3N3j7q27/MPv/QbvfPMOo9EOO9eu8e2fe4eQlfzdv/uY4APzq1NMXvKDH/0+9+9/ld0br7BzbUz/2/+ad394irMLJuPrHN68QWUDewctrzw44P1PVtw4uM31awWLxYJyEulWF2zte2x7gcmnaaRCT9eukVJRjvbQckTn1yhd0TcbcJ4gNLWz5Eqgi4gTa/ARo0dkOqP3BZPZjKq5pGs808mUxXLB9s4W58efI8U5ZdEhTY7RI4QMRLFBSs9kMmP/8C6ffO9D9pqGWy9qJkcbLIbLXrGUPeuZIL+5jdrJcCObFmWyJ6gI3ifSrlYQEmEnhiQBkUolx0BMTpgoFFIXRJnoOlp7jAppQUY6bZEHWhPogyB4R5Elf3hnLTJEVDbM6bwghrRYNJkagmX8oIAgQWKlwvUR51KzoQ0IadP7X6YoTRFfKiL+fFtURwp2/oEQYgp8Xwjxm8B/APyLGON/KoT4j4H/GPjfA3+dlKb1GvDzpAzVn/8317fEgnrpFvDOpgBk5fF9gVQmCXeRCJ0ekAiQaU0+zuj6ZJ0xGSk3kWQHIcZhDqeZTvaR0lBtLuhshZJpcClVOk6cnV+gdNIOKa2Gla0iJkt+wgzJIXCatLoOIRA9KJPRdylNXuuUwRmJBCfwTgElIka8V3R9WrlPticEr/gLf+mv8NnjExarmuP5Ga0rWFw50DtoFmgtMHKHJlZ4D31vMdOC0XiMiIbVeo3rAiIm2bMwEikycILoFbZLUYUt8Oq9+3R1YH1xzne/+7vofMK9OwfcvnOPzz57TlNq8mJEIGNra5cYYbFc89nDJ0SjyE1JlmmKYkpfnbO3t0P3YoV3PYhIno/RMWVdIj1Yh3WO3vcUuSHPC7QpKUY7xFBCCHR1j2sbVm2LpEMMqPXOtnQb+N4f/hG2r/nkY8NXv/oqb77zNd7/ZMm7H71LE7d5+HyDUo6f/wu/SDnO+IPf+UOUk8lrHC2ZKhiNbzPb3uf2nXs8Obokil1CsOigOfn8Ea+89hqrTUPvep48ecTxyRHX98YEqahaz7Onz5D2imtbMwIOKyEwTqcKaogBY0qM3mJ9eYGzG5QUKfjHB4Ls6IXGd+libvQYU0xwBMqtbVwbWFVPkFKzaAq0VpyefUCZHw5q94yRDHh/ish3GasDbNdj5885nl9wu71g8vkZ8WzN2keWsuF0NzC6s8OohLoQtFIkrakSGBwIR6cFygdc8AiVJ6uqCMOSTRItqIHdFqImygzhA1MZMHhykVQLwSYZVaY1UndE65IPVwq6PjUrkYQASzTppA8NwicytZBkMjkdvEtH/N4mVFUQoLQYPOVpdhejQ6mIKgxd73Duz9HBDfGAx8P/r4UQH5LS6v8W8CvDp/3nwG8PBe5vAf+3mHwhfyiE2P7vxAz+WT9jWP8my1aScQRc3yBzkQzoMiMohYhJ5mHyHE9kUV8RbY0RgVyPaDqRUEjRE1UYNlqBerVAKoV3DeCRUaJUCoz2MaJU0uGEGJNY8WVItFAoZQg+EJylyF9mtQ5WERHpupbgwQxAQRFjAkxGCUHgiTgvycqS3Wt7CJHTtTUKyfPnz/EEri5OsWvHLBNks8BuLmna5I/c2tqi3LvF+eUG5QNWJRuT77r0ApKCrFBpwaILYutw/grfL8AlQW83d3zWOuToGkW+z9pf0J284OiFZX51xSuvfQ2TKyyRvb1bPD86QkvPN7/5Teqqpu0CSxFoNj1bBzd4dPGMraJgZ7rF+fwCFy3OdfgYv0BL+eAoy5K2hbb3WNewt3+T6WzGpNzh2ZOHbOyK3rb0ncNal3yUPgm+lYLgO6bTLcqt67RhxtOThrd/9lUWF0vO59A3c3b3tmj7iv/8//7POHl8RJYLZCjSxUaVLJZHOHeLfrnhW2/c5/bBNkW8Iria8zPJqvsRN27c4+OPP2c6ucR2Frmbc/L8iMVyybgQ5FrwybM51w8n6K7i8PAW84sr8swkGjPQNHPAkucG13fEkMLIE9A1YmRGCB6lStBjdDbBdYYQlyh1hQ+SrdmbVGuYTfdprccZxXqTjsATadBOIF1gq2+5cbIiO/ZQdSyayNNYIg+22TrIybcrVqoiGuiFAB9ReGyISZsmBCroASIZiQwh4eJP5lpKvxzv/4k2VUoI0uOw6DhAM6VERolzjuh9oodAWioEgbMxLfdiTF8/NB9KmyRDjZIYeqx7GWqd4/EoZSlLgZKeEJMUJHif5E/RI4XBGE38/xXwUghxH/gW8K+Bwz9VtE5IR1hIxe/Zn/qy58N9P7XAMWzPtFSYzKT1b7SE4LB9ixQaNcSjiRApVE50giBTMVNIYnQ0dY2Q44TxxqUlTSQd20KXwJMKYlTEmIS93tvkzRMCKXMyMgIRl1KekSiEUBjN0IV5hBKISBIr4tNjGEKFCdB3qaOJ0eJJBmPvNSYr0GbC7fuvcPziKf1mwXJxwWJZQWz4pZ/5BapuTmx/jIsNl+s9Tk8tyzrjdDNhtXFU6w1CayZZQchisrWpbQKRzrmBY28psoBtW5qLC7yr8e0FfVWS769p9TW2JiU7e9dZLS45PTnBupZf+ZW/xvaOonWaO/fu0lZLHj96zK07iWQbXWQ23UYKybVb93jy6ftsz6bIeoVfN4QAzjfpKRcKHyx9XyfqiclAKM7On7PenELQOOuwtiWQZqjeJYx6OZ0QRSK37u9f41d/7a/x6Oka3yn+8js/yz/5rQ94cfoj6qri9u1t6njJb773R6xXKafUWclXX/0ZNo1FFoHr16/x0cNHrLo53/6Zv8nq6hQdJbfuv8pnn/+ArXFACc9yMWdzdcFbb71J13W4rqWIDXuTkt29HaQQbOpLRuPI5eKIEC0qaITvWS6vgEBRjFI3HwJKBEKQiFhCFDibxOd9P6f1DabtyI3GtRegKrQes1lfcvPmzxPIuFw9SwFCKHobudyM2C8kd5qKW99/xupxzfP96xz1gbCdcfD6V7n7zjc5as+xl58Q+1PQHfguFa4YUUaCNECOiB4nNT74ZHkclnRKqWTylxk+5MPCwJLpjsI4jOmR0RNJ+KvkHU9QgDI3dFbTWXCuAe/R0pEpSRCB3gW8l2hh6F3Aeo+WyYopjSbY5GbQGnIDRlgkARd9Ig4FwcvgaB8dIQx14M9b4IQQE+AfAP+7eFB1NQAA8PRJREFUGONK/ClGSYwxin/TKuPP/n7/IfAfAuxsjdJRMipEMCAVUucY6dOcICY0sZTpyXe+R8Whkoc6efViTLF4okoDWJGi3AIxzc/CYDIOEa3zRATRSR0enMdHhZcBJXqkzMh0BlLg+iaRSgUgAt7HND8IIUlYpBiM9Qns520K5QiCwS4jsU1EhpzZ9AYHN+8hswxrIxfnc4ROS4r9Hcnbb9/mZDFlff6c8faUD/75U5bxFperE/YmU67kmp3rMy43K4RtabueznZIY/CM0JkiNBVo6MOEOLmH6iXdxedIKnBrwvwhajJixYQezWxyHemXXK0rfu/3/5D9/RvMtva5c++Qgl2eP3tBs1zT9R5jBNtjxaJqOLz9gBcnZ5xcfs50a4Zr19iqQwpJ718mN0mEkvgg8C5tvfIgCF7jrUsjBJXmqEoZMlNiMonOxyw3NcH1HB+f8Rv/8Df4xtvvsGngd37wYy6Xp7TdFeOpoHcX/OQnn+F8l9hwoUeIgrPz57zy4KucXZ2yWqyZXx5zZ2/C/+X//Ju899EfcPfebX739z5h/1qBUBM2q3PaasFstsVsZ8Km9VRtkj6MJxPGxYjZZJfzq4hUHX3fkutsCPNRxNiTZwEpRkkgPiqoNzXaKFBD6I9Mp5RcabyOlKagWp1iVEP0BV4YTL7havEJUm/j2nOqxREmSHbLEUW74v7HG/ben3P1YsXvTzLauzcZ3drn+qsHXH/1dRgZVj/Z0NgF0XSEmFLqpUqLNKklIagU1iJTboKS4os5vTEKoseFHoEnL/Jk2u87Mt0gZY8WPikRQvKG+xBRWhJRlHlASwHRkxcZdWsHtUKkbx02yEGsbEFKjMwgDjq4GJOAVwS09GTSpyVFiCmmIAaklnilsE5ibQSZliJ/rgInhDBDcft/xBj/q+Hu05dHTyHEDeBsuP8FcOdPffnt4b7/1i3G+HeAvwNw59ZeFFImj6fK0lq6r9OTH1Nmgo+eaC3RlAl3JD02tGidKrrUOVEkhpbAo5UGDSFB6NE6Q0Ug+qSpUwUCSZ4ViExAEPR+jYsV2JroBAJDDEkMzFDgpBBoNazCY7riRSJt20BMORKEmK6YEmJQtE3PuDDcvHWbxluWZytOThbMtvfJyhGb5RWZWHNy/GMqXxKFYrPy/Py3v8P3frzi4ecvmE03jCawvbvNyeqU3m3orKfrNaGO5JmgLHI2sacLAbRBmhl7r96inR2wfv4uuAtE3yPtMePtaxSTa4xkzXrVc/PahMl4wv0H19neusa773/O1u4ue/t7PH5yweHNXdQo5+n5MXmxi1aS63e/wuPqis38mKIs6bqOtnO4IdeCCEZkKJ22yluzLWaTKWU2oihylPb0fUPTtXiXLkjV2jHdnuLiCqIkzwN5uYX3jvu3J1yuT7l1W3J61LC8OiIrNOX4OttFzttfe5vFquHmg7f49KNP+eC9H/OXfvlt/v7f/2fcuP0qT09WKNUw2d4mSM9ifUox2eNg6waLxSnOW5RWdG3D7myHG/vbWDsFVZPNtpIIXCYx9bX9O3hXs16fE7xFDoEqO9s7nJ6tEpBhyB8ttMZkiq5PoIbUHhnW1Wniv8mSoAReQmSHG4ff4OToExp3TlkUyEaxY8d8bdFj/9UzPjta8XDSE17Z5eDQsv/mAzohcbbn+NOP6OunIOaDhTGgpU71SwxyKJnE6kEIhE8jIh9TgLOSGSH2iZ4rPdHVRE/q3LRLMQIIvEtHWaUkSE/TdcTgk4smJl1bUw8XeukpRiVZXrJYbhDKE0U6fcWYZtZIkFEhRQDhMcKTaSBqepvYkBGd8BpfpGnFQSPx59uiClLQ84cxxv/Tn/rQ/wf494H/dPjvP/xT9/9vhRD/BWm5sPw3zd8gmdKt7ckzgXUN0jlktBgp0l9+KDBRMKRuJaW+jgLZRZTK6Fwi3CICmZEEIQguLSK0yBHoYSaXZiKJgCDx3qX00KiQKkuiYNl9MQ9QyiCFSUUu9BB7ou2wPlmh8AGpFSomiUmykqUdm+tTa+2jxxSB09OPsCFyfFrRNJa33vkWZbnPD/74j4GAba5wdo/n54qnT89YbC45nW/wVcUHn25oTcuzj44preXWjZJrO2PaVvPZ8461bXF9g3bpWEgfKXQNQbN7eIuDvTF+/hO66jnrzQl+PaEYv8nu9h6FEdzcg5OTSz5/+CmT8SW/9su/xPsfPqF3l7z6Sob3HZfnPTuHeyitaLue8Sjn8OYDzurAxeIxZAYZHLFrBk+xxIUOEQVbZc7+/h672zvMxltIqWjbinUEoqTxNYTIX/2rv8z3vv9jQp9hcsVkXFL1gYdPj/j405YQPNNRyWjk6XzGum5YrR6TK8Xm4py/+lf/Crf2e7I3JmyVN/jx+5/x6jtv8bVvfIfTx5/QNjXjMqNeOmKUOJtyOrwfunPg4w8/5I3Xv8ZR03J47Trb5RjheupujTaGIp/i2prOXkJsMcpSZgqi5NmLp9i+gpAuklkeKTNJbwOFMQQNISSzuRCRKAvavCQLgTx0iNBxdvYR7foZ+0Kzd/Bt9sM+W7/5PZp/+mO+e/WcR3dnvPVL15m+ch2RZZy3x4QoqDbP8F2LlQ1GCryXKFWmgG85EHsiRBxCOBCCTMdBhiHT5o4OLRxK2SS/CoIY1WAHSwJ4ERU+Opz3RNfjBk5bb33yZ8sEvywzg1SCthcsryxSenJTJp6jSNRf7xIaTWqddKYkQT6RhFATijjgzGL0ydngUreXmBh+ULf+9yxwwC8B/0vgJ0KIHw33/R+Gwvb3hBD/a+AJ8LeHj/0jkkTkM5JM5H/1b/sBQgiMFOBblM5SzgEqpVwHj9aRqBKSJfnvQkq8lqAxBKFQSiOjIQRLlim0kiiVkZkCKQ0RlaQc0aajpO/wLuGPlJbDxhSCD4io0dpgsgzvSarrkISGMbike8IPFGGZEE8qBbporXEu4Dz0faSPHhcsQfSsVycEIptFx+7WXbwVqPGIt955m/XF79K5c9794DGPLg1Pn67Z1JJVaxFE8tgzrtb0wmO2t2jVlHkrmDeeblySixGx76jEBm1GqKIiD2vu7u9yfvmM2WybCyvxHmZjTVZW2PoEtz1FmD18bKibp5i8YGcWeP/9j5jMRpTldZ4+XvDglX1WmxM28zUdSUDoPOT5lP3rD1j7ltX8ETFIMpMlV8kgstYqRRbOr67YrJaUeUGejxFCUhYZWSZYrubQd/zWb/02MWb8z/72r/PwyXOcDVxdnLNerml8jWtWaJlhQuDG3j5Va9FZoO06itGIx0dXnF16bhxmLBeX5NkeX337HWLsEULRO/jaq4d8//vvkZc5JttiudzQtA1aBvquo21qVus5QWmct5yeXhBdxnSaMR5PsY0lioqurlBG4LqKLmr09ICbN17hyZMP8GGJkB1CW4Qy6KixLjCZTOi7jrqtyLOS3nnKUNC5nih7pF/jNht2i5zb/haz5iYnZ46PfljxqOkxf+MV3rwrUTenuFwhe4EGHJ4YW1zcILVMOjKVIgLdELOnZJrDhRATKUQE1JCyJUUKZVICZEinkhBscgRJ8wVl1/Y9BE8YgpuE1GSZwfpAdC0oKMsRSoLrBUF46roixIyIxWQapUwaO8WePFNDQFQ/OEDiIMJPXVrnPLYnNTghxQlqmayHiIReCu6nl7F/ly3q78FPLZG/9md8fgT+o3/b9/3vfFWycyjI5EsDvQYSxqh9GZZh4sBlc2kOoBVRG6Iw6YnHk5mXbgWVjqlSobISePmkmWRxEmIQEJPO+aT2XchUJAmBvmsAhXPVYNVKHHqlFUYYEipJIWXAR9L2yHls77FeUPcOpTK2Ztu0FpquRw8uitl0xP1710F4Hj+5oK1hPl/QWsXl8QLheyZ52ujOG4tXBZkq0MKCVKy7CfMGPBEpPLbfIGNkMh6Re4ftYSwycq3Rbs3utGTrwSEXpxu6ZoHO1kT5HB2mBL3P8bphsn8DjeBqMWf3YJ/1usKonLff/AqPHj0m2MTVcxFsSOib4C3ZWHB48xoqtmxWl0S3SWQVadL4QEm0kHibrrbepOdbSUXb+8TWMwoQ3L/7GkpOaGrJ9cM3OD49pW4uKIoxR8fHuH5FhmRdK/amU2b5FmU2prUr1puOZ88e8vM/+7M8ej7n4fGab7z9DZYbz0fv/oC9WcG4NIynBX0IRGloup628ajMIXWyAY7GIz756EN++S//JQSWNro0GJcFXb2G6Flvluzv3aHtairbgJBk+ZSjpw9TNqiMaa4rIs0gZSjKUUrWUgXRVun4Zsa0XtOGwJbJueYFO5uCbXWbi3/5nKcnz/lBtWGVr7n1V3bYemcLvy+JOOgtXgq874cMXUV0BUFETFYwGk+o6g34NtkHlSKEnhAG7qJMqXFSaLK8QERB13XYkBZnRAi+x0aPUAoF6JjE45HE2fE2ncCcj2hVUGZ6YDhKAoK6chT5GJWlP1ubUPKZEeno7FMWqtESa106zXmHlRbMsEwIoHRIaVyEIe5TItFIN8XbyU+tLF8KJ0OMkbbt0VoRfI8SPllAlCLLNSGM05ldkpBKrkO7BulTyxxJ2YlGmUEQCCrP0XmOUiVSZ8mUKyRSGLScgEgzNOG7FELjLcH3ib4a03YyDnKHEEJyK4SAlIlQktwMIFVEmRzXJ8R0jKlFDz4OmjLBaLrD6XmFdwZiQGY556dP+YN/eUndKC7nNdu7kSdPHI+P1ig14XA64sFXdrhazvnkccfx+YqDwxnBObwH4iUyExQiMhKw1IKukfQ+oHUg0wV2uSRaz70b+8wygy632Rq9wsnRJ9TVBd51PP9kjShvkR9+BZWP2NqZIAVkxTZXiwVV66mPHjKeTYibjLOrM8rpBKMMxaiE8Q6rZWAktrlxO+PiOGOzOCG4GjCDjiq5G0I0KFVSFCMmszGj8Shx8qxnvzhEoRmNRyiVs7c35Xt/9ClBOJx1qDxjtrPF+dmGZQvTnT26DmZbhhs3rtP7Az7+9BlCe37zu7+HUoJvfPPb/OzPfY3f/1cf0feRal1RTiLr6jqm3OHW4S63b+3xe9/9CaOxIjOag4PrXM6PWW9aPvv0Q64d7HLnznW83VAtr2jbBUVWUpYj2k2DkBGZjUBrLk7PkKJCSUeWl1StIzhJUCM6K8BIxqXAB0M+nYHMULHE6oxrXnH/zFMczZFb13mUz/itZ6d4t+Dut2/xYHvG6G6g2lW0vaXQSV/nbI8a/MfWe2SRU5QlRo7ZVAuca5BYpEySkDDIOhJEMl2cRYxEW+FjhzYGG1NguhaeDIH0yekQXIfJRwiRQK4pnBk6m9wKxhj0IKh3vkcqx2hW0jtBjA7X98gYKTKFooUQBnsjONsOc70MpUcIVRJVT3ApS1Vp94UxkxCJXuF9jjK77B3e+6m15UtR4EBSlLPEn3L+Cz9pSrsXA9k3QdyjF2ihEHmROGc64cmVzJFaIJVD60EJbR3W1Qg7MNJIVBFpMrIyJ1ibtkshDVeFKYdQ6JSN6r3H2ZYoJAGFVIPn1fuBQDp0dSEdxVKaVzqKKJURSdjoarOh7xqkzHEhUG825HrEeGeH44tLJqPXuXb7W7z3+J8R+JRJPsYpwUcvLlG2Z5LB4SEo1RO8wuoZur/kq6OIznLqYpfm6Bxkg/Yek6XwktloxpiKiCW2HSFGnO3QsSRTu0QjsL6j9wt284xoplwuWka55uT4nJ29Ee98522Oj9Y8ef6UylWILCN4z2Q8TmLWfJTeVFVNXW6SEl1L6s0lfsDQG23IsxytDEVRIHTG1dWK1XLNaDxm9+Aae/v7LC8XEDxHx884PT3GZBmTUY4RGzIzQgBvvP4mfa8pxyPqas3e7hYxeA73bvPG11/nX/yL32VtCm7sX+O1e7dZX3V8/cFtTh8/YVMtEwV5tMvdB4rjZ59zsFdiTGA63eLW3ZuYYo9JlFwtT/n86REPvnKTqlmRS0dbL4lYnNMoCV27JMoWMxpR5jM23RGtbxJgsnED1aWgsxn5dEr0Aek1s9hylacThVlHbqwX7L97yvMzy/Ktn+OD55qT+WNe/8YD3v7ZGzR7lt7N6cI5sT1Dh5ZgxzgfEWKMiDnRW5QR6DIj2EjVL+jtEqMjLiQyiYgZw3CLlwTtEBxCeFS0xODpXEgXIi2wQ3Smjy5lO4jB0hUjEj2IdTtGkxyT5cSgCEHifMC5HC9yrPN0fUvfbCiySCY90vcIkeQvIcRhS5rsCkV5k3y0x3yxpu8vcH6FBGwfkk9cCIZMaGLUCKEGW+SffftSFLgUfyqGNbEe4gBTxqP36djp+4QZkjHNDLJRiRcRG3uM1Cgh0YCOgSwIpPP4EAnSIY0DmUHwKSPBOmrfJDTT8Isg0htWJ2oJItmvymyED5YQLcLbRO3VcaAlJN8sCjQpjUhKgzaOrBzTtpbYJ4Hi9tjQufRY15vI6eUVR6dXTMaH/PKvvcVVLHlaXceXl4ylpKoaljYn84JSe1TcwlmQeUYpDePxDCGhsg3r5py9yZiNbxDGMctzdOzJVcDXQJa8k0pGSqEx+zewwbHaXGF9R6EjffWC7b0p5dY1+r5CELh4ccZnxfcppxNeuX+djx8J2s7RdxazY9LGDY2Khv2dbdpZR67TOKAYj1mv53Rdi0qnclywCA2bdo3G4zqHU4GL857nzx4SrEMbAcJw/PiK64f7PG9anPP0UfPOd36BerPh4nxJOc65dX2fzeqI50+f8vCzz1jVG3b29nnz629CUOh8j91r1/id7/4OuY4c3LjFW++8yY/ef8jtOw947/sXvFufoZRmf/uAve0pRo34C9/5Ft/97h9ydvJDdmYF/ZC+pkwOeGLsWG8WKJlIMYXcxcQZ3p0TfMTEMBQBSfASU2Q0XYPSIzZNTrkV2atbJmdrbq4k57/3gn/yeMUPru8z+2zOTub52lvXeOutOxzee8Dx5RnCerqLI4wGY3OClFiXGIrjyYT1+oIgJZtqgRYBITXIHqkMwUaU8iiZoJRRSpyL6WhLSELfRG8lOomWQ/GShhhMchgBSmlCDMnZI3KkToJt21V07QlFGXAYeiup20Dbe8DStyvGmSA3jlw5ovOJ3agzxJDbS9TIOKWYXGf34B6L1WNwFiFWRO+SiAEASaYkMRicGOGC5Orq6qfWli9FgYPkTtBao6RKwa7Bkw3hMdGFFAqtEv8pBhA+tdfpyenQOrHeeGmRiSFteUjJQkLoZOR3EaGTAhshiSGAUKlND4FoRVo4qCQPkUIjjCEETUAjUaQ0ruQ1DTEQVIIEailA5cgsDEw4cEKQa1AIpMpxUXK4P6Kuzqn9BtFe8l//9m9x2c/oVp+yM6po+gxVKFwLMWb0fc202E0vDu3QucS3ihrP1mTGxPdUTUt+cB3XW7K4QdgK73qCjCgENlii8oS+ZlWvqLoK2XsymaOynGIUqBafUo5eZ9N0XF1coELLetOws3eb5eYRW4c77O3s4gY5SBxsbtPRFpnMiXgmezvoTNOtz8kvz2jbiqpaQEjzN9cn7M2qXhG8Y1lVmEwjpKJra9o26Q5759AFBD+BqLl5cECuM3788cdsbe9ge8EPf/Qx0S0gQr2JLJqKs8tzrq6WPLj7Oj5KPnvyiIvLZ4wyx8/+7C9wtVyTCXj22YdMSsPObMrp2Sn3H9zkYGebzz8/4b13V7j2jCKLVNWa6zdu0LcVbdUhhQK6lNerI6Nyh+2tfXIz4/T8GVhDlC4FGaMoRgVKCbSX+K4F41B9xvWLkuK/OeFpVfFPLxZ8cpjzlVd2ub+vuHuzpLgzYS3PaJ5eQV/T9UfI2OKcGoKYM4wRuN6yWpwmqZOATCUrEyQPpw/JTy2HXyEk0m8IiaCdcmiGLWoEaQxamcSyiwIfPVpFjAQpHNATvcDkW9y4/TZZtsfp8zmbjQRe0PcN603A2bStjaJDyYB3gSg8LZbeepQpiJ1PaDIFgR4fOpbLM0ajLXx7hYhzpEyjHwFoJehtj3cS7wVRWSQ1fb/6qXXlS1Hg/iQCLBUlpV6SSz1KgNYZkiGIQie0TlorR5QbNIrKp99a0ce0XhZaorMxQqUYPGTy1gFok46wL7VtQiQ0OVEgXxYu77FYUhpQYpIIndA/cVBvQ9qui5j8p9FbbIJeoZRE6bQJlloTO0XfO2KM7O5MmG3naFHy9PljFg3M8gmtHdFuNvR9B2pCkMlypExHrnQK0IkBXwq2Qk0uNE4J8lwhjaGLHlc3BNdgmwolJDG0NN0GAXT1krbbkHvH4WQPl+1Sixxna/q25/HjiB7fpByV/Ozbv8Bnnzym6ZeMxhPatefJZz/gYGuHyfYBo70RHoGLHtt1eJHcCEJIyskOO1LRNBvK8RgtYDVfEqxlVI4YZSVBGM6vjlFR4lpH1wX6oOhdizQ516/dZjq7TdVE3n77FT79+CFf+8a3qeqKq6srhIAsn1FXjk03R0vNaDTi3u3r/Prf+Mvo8TYf/OPf4eLsDN9fcPkPjvFeMB3vMi4L3nnzDu++9wkuKp6dzvn4w0fcvnnI+ekp3ldkWrE13UGgyfMZMYCzVxA6rGuJUrOurui7BiFKtna3qZoGW6eErcxkhBhpmoqRMuRWMF60hB93fP/pgmdEqusTxl8d82uv5oyvl8TpiFpu6NQRk/wu09EBx8d/RK8u0TqdCPJsggtjlBhjlMH5JS52jEeHxGCo6hN0Zumdw4eI1kNGCCLNvEjjnxCHpZmUaCNxvU3QiyiRMiMKi1Qp6EXTQwxY15HlJVmWkWclWZE24V1TEnyBcyuksuQqNQLWkdLFlEGIlBImdQqBljFFCfSdT2Mg0RG6U148WSGFJ4gaERJPTmuF9Q5tNMGn2ILOLwZ3w5cclxQHC9TLPIY4SJO1HkS2kLosIZBKpE4uCvB+EN6m7s0QyaUmBE0UOaPpFqPpNp21hNgnf2mQaf4gIkWRp6XCAIv03iUzL4MlizjofyB6n0J+ZeLJBe+xoU/yFKmTD++lxghBFMmKJFE4JHUnEhNNa5QxafMZJOvKEWRPUSgyZelt5MHrI06PFcuqpAkd2pRYJygyRy5T8vm2EZgoiVIjvGNrIrh3d5+f/PGPEL4Fo4EUVxi9JC8mKKHJTYm/fE6o5tSqoeoWyNEWSnn2tkbEbBevxxijubg6495XDnj08HOykcZawfXdrTSPWp3jlUdkJdvX96hqh7eeUZGjxxnOt0QJKsuZzfZSF6439E1DZizjyZiuE0x2dmirFV0dMEXqeq7t79JFzd0bh7z+5jfZNFNWqwvuvhY5u7rk+YsnzC/mKJdxeO065XbH3p2vYEjSg/uv3EdKzecffMBrB1PeXa2ZjHNWiyU+9GjlODvb8Ozpx2TZdX7uF36Zo+eR87MnLBaf02w23Llzm1/5lV9G6QJExuHhDU5OzpKXVAIiabbwa4KoybIpfdNA1zMSE6SJWNEzbSu2zpZMVoKjFxULnfN40TC5foPXfvEW2U6EghS/V2jKSU672LA1uk7dLJCyY8QE6aDXniAMkYKyuMP+7ldYLyuOzz8kzwyjckrTpONpiE2yXwn5Rf5ICC+PoyTUWBD4+DKOM134kzc7Ge6DSLNwKRXeGkLoEJLk9VUrzs8/RokZTdUTuMD6nhTXqQg+fc8QNFLkIA1RaIRyCFoKPRjsXWS9saAMznUo2ePchhBT3+l8gmW8bHzq1hGswGiQuLRk/LIDLyF5QfXLLmm4L35B8EyIIh8SoSM9eQEhAkoziBiT1ctbgdQF5XiG0SXBgx70c3FIpnddS8QmHtlgt5IyQ2qDjMNkTnhi7NPWMli8s4PXdEjXwhFx+KCHgpy6OogYpfCkrVUUESfA2UA+AlMYLi5XuD7Q9pbNxjMrM5TJWDUO5QLGFWTREG1q4YXvyXKViqDMyEWkUCaB/3xGpnt8f8nHP/nXEDoIDi8kpswRIaCZEnx6VUcFdbmmd2va3OCIjIuIbVqEiBgzp6s6Rjs3UZlkvtxweb7m/OIKnXm6pmNrPGZ7/xpdvcZtGjbZlN4lAELbWhAWLUGrktZHopBIo9i9toWzCmMkJrNkdcP1/XssFkecHm04OJyxqW2Ceh4tefbwfd547au89uo1/t7ff8hsfMhy2XBt6xUm8gU3D/bRmaGyS549eUK2tcX16w/4xls/w3s//IB//Bt/F609eElVWbp+w2hccnZyRm87dne2mczGvPmNr/LJh3/MZrnBdhWT0jAeK05OHyOA+/cfsFkX7O7sUmWO1VXP1taI1focrdLG0XUtIbTIXKLlFBkj43rOzhoO5TWezC95b92T3Rmx//p1dm/sYooryhKcHBGtoq0tSlYoEdlsTslMi5YHOB3xNsP5BhMniLiNkhlPPn8fpUtm0x3q6piz089AqiHlbTOEpiekd4iJfqNk4gZqrdKFPaQ8U28tMop0ShINAILBdhghaIhWUWQTIjlt75DuikJf0vY9TdeijWIyG9Ffepq+A9WBipisRJCgFta2qCzN1IKPBBvIsgwvIEeCgM57vJf40GO0HrzlqWAKodBZiqjURhJisgL+tNuXosBFSD49KYYshqRkjiTekxAC6zxaSJRg0K0lwoCRyfiOEAidofSYYrpNVhZpS6VUYr4PDCohRQL3DZo1IQVCKQC0VsigCSE5EhICfbjCSYWMAbxP3aPMMVKgRCJS9q5Da4G1XaIoxETH8CHgBYymCutq1psC1BSlLFqumYwz2jat2NvW4kRkfdUwmyjyac9m05HrnFynv7uzEq0LTCY5uPYKp5dL3PoF0TcUxjHSGSFu0/tAlE1i6/kSjKaqVmTFiGKyN4iVM4KvqFdzMpkhjcT2FcF6Nps1x5cryqIgyzRb21OWiwuEicyvTml7y2z7EHTBi6MnFKMdTD9BZSV5oTFKkYnAaLKL1IJJUTCb5GihmGyVED2bqxWL5Snf/vZf4vHsGKE8u0Lz2t2bbH7nj9i5ew+T53z64QU5I3Ix5xfe3KOuSh4+7Ll9Y4fT8xecH694cPsBxWTMK199neMXT/lH//jvUdkrtO/J1Rb7O/tYlzFfzNNcNRiu37iDdSv+wX/1X7JabTi8tsXOzh22ZjlPHj3m7PgZ3/jGV9HxJl09p+82dP0ck0fqao1WCucCUWQYpRC2Zbzu2HIduuooW0tfw/t+zvyGYe/rD7h+OEaENaLoWdmexmuMaDFSMTISaFHlhDyr6eqOzbpi0y2wKLS4iZa7+OA5v3qPYFtKeUBXGZquRgDjyYSIpZ9XxMHrK0hZCEZpwrCkS3OtNF8jpnBzXEwXbMSQVjdIOIZ5uCpLhBjR2rQtLTKD9x0hdFgbUTqj72py4+lVk8C1FAQEbiD2KgWZNMleFSOonBAk3vVkKsf6ntHY4JxPqV1C0LVJ7eCDJ5I6UpNrhJLYHnxQP7W2fCkKHBGCDQlOKRWKodsYnAIp+yASgD4GlIhIrZCkrFOlFdpkSKVRZYEqMqRKm6HeJYqIkHJIsndkWVJtp59BAvvxUkXNEI6RjlxyUHprrdOxVQe0LFAmR5CSuspMs9msQQic7elcIvgqkeL6emdpuo7Q5bz6yjfpvGR5dcrl/AV17elFQ12v0FowynOk8tSNw/uMUqmBtCqo+p7JZESRgbY9GRYTGkJsycuMtmqJQ/gNRIJvSawyUCIDOUFmBde336Dfvom3FVeXR3hfU+gxKisIKmMym3K2XP9/qfvTWN3SK78P+61n2Hu/w5nuVDOLLFZx7FE9SN2tAZIlJ3KUCLGTyHZiB4gR5YMMw4g/CPaXGDBsIEBiI4gDBZ3YSAQ4USwrUWRFU0tqqdXd6oFsstkkq1gs1nCr7nzumd5hD8+w8mHtc0kpYktWO0D5RTd4694zvefd79rPWuv///0J8SUurq6o0xlDL+w3O9pFYDdNtF5olyvaxaEV8PWSxWpN293gYNWxXmY+9YnneP/eJakoN4+PmbZnLGPiD/6BL/LLX32P/WbPZz77ae6fXvLyp1/k8595mQ8/ugfbkZ/5wdf46T/wk/zaV77Npz55wi//yjl9r9z98BGf/szr/Pgf+mk+evtdmtVz3H5eGdLI6y9+jsf37vGLf+9vsN08QaQnhjXOOS43FxyfHNMuK9M4oK5w/9FjSq0crBJHB7f4PT/1Qxwedvztn/t5NldniAqP739I/MHPkIZThnGH+IkQg4EE6kQjlXVcs9RIGUbK455N6hmD8OByy/p2y82XDlh5z3LhoNmCNkw5o1Jpmw6kon6LuInNdqTjBvvNmtBd0bhKK4esF7dw3OTlT/0gH9z9Jv30GPEbLjYfEJoj4qIl+CVpEoZhwodocMspI/NizFh03hw5WgwYMaORcjXrVM0FrY6CzKc3o+3gFWkjVQrQ0XUtwSuaLSCmCUAdGIYdalZophzICFUSXVQ0W5HTAgVIOVDEkfJEFJln8JVcbb6dy6yFbQLBe8ak5NFGQD6a0d9Ycs33LS0fiwKnQFFw2VT56sVAdyJ456mp0C1bfOPp9z2KnfSCCxAc4gOO8Ew0KMXoHykNKA3i2jltas5scNfBFWoI5XlQqTg0VPJkMXFBZrIvChpQFXwMeN+h6kE8qRbSfkctFVywU6Q6gofiC0mV6Dy5KHEZ2Zw/wHfH9Psr9n3P1bYw7EaCb4wb5jMpQWgaWxCgljYUGk4O1riYGdNAwfHk8QNqGkAKYwZ1a/ANpaghp+OKnCNFHao9Mm+hQ65khbA+YKUn9FeC0jCOmcKES0Ib1pz1p4T2GAmBNvT80T/6h3n8cODd+3fxrqfxlTz0FDpGJo4PhJtHHTdPWsiF87MLgiqlOh4/eULjBbznF/7e13nwdM+tGwvuPbhks6v0zY5f+bUP2Gw2HJan/MyPfZpf/tWv8su/8T43Dm6wXt3g9u0lv+d3fx6k4W/94t+hXj3l8vKSVOGNH/g8b739Db71ta/x5PIxBCHKMScnz5E10y06xlRYrk/Ybu/ZbKo4muB56c5zHK7XPPjwA/783/v7lFpYrjMH65uUWrm8OsN7k7A4Z9dB61ukKMsYWAwwPXpEvTrnKlbKSUNZdRzf6VgfCsVPRr71loqGd3Qxst8P7PcbDg9O2F5e0C2EtnGsV2te/6E/wLfffYxzl0z6Fv3pe0R3xrtXD8khEeOC4m4Q6/js66ayI0+DET5KJgZHGzujYzN3PRRqtYWBd9AFz5RGPJVUDVsl0lFKJKVCzqPddGNjbDcdcC4h0iLiGNKefhhRHP0+4/yC6jylQp3DAoLbE3yiqielkabpGKdE0iUVpe0yQYVpDoRWZBbVB6ZaiUVxVSnFIgdrmUk+c/5xlPb71paPRYETMdaaeqEGZ2GwCOL8nEkayKmQVTHOuFiwhw9UN1MR8DhxlDHhOzVRJYbiqXlCBaoYhtx5Y1hZIpfiZt68YsncqhkvNlcTHE1oCGGJ5WjYLAM1OUrbdex3IzGagHUce2KI5GKeWSqkITMOnqo9V8OHjNNTri4z6iM4hVBwAfIUEHqaxlGoaBCa4Fm2keBsDjFOiTYkRAtTVZCRJmYmCaj3aPUIAU+maCa0K7qwZNF0jFPP1eYCag95z+6y0l9trGDWPZqTDUCnnrB0DLvL+XTbkMPAt996hw8/+JA+TVQmnPuAz37uh7hx8w7rwxOcLHn+uOPxw1OWywNuPn8LZccnnz/h8aMrrrbnPD3d444a4kr44FElhsQrL3esj074ytfe5mKzox5F3jp3fHSZeP3zL3HjwPPGG59iu58IUnn7nfeo+8jl+RUu9BwfNJw+eI9+d8UXf+Dz3H14BDi8FxbLI8acGHeXlKtzdldXjH3PSy89z8nJmpqVmjc8eXTG40dP6drEpr9gHBvGKvTJfLfeO6q3RdKBdCwQgkbSvSvOS+Vi2uBvB9qjlratTFWZqmdP4qhtcaEwTANSG2KoeN+SS2a5XELwrE5uIL6Syy2yu8m9h1cs14X7H3yd8epbxFiIx8fsNlum4Qk1RKI/ZNEdIW6in7bkPFHS3PmEQK71WVbwtYdaqDipWB76jPnXCVWPjwHXtOCWVFaEknC6pKaEOm9BUFqhZqaxspvyLOmplDJR1SGqhCYSvMk/NE9QMsM4mqjeLRiTYz9VoEGYE+xrYRx7KhDahlKrsd5QcB7bWbiZW4dlm9SCarRApO/z+FgUOHsYY8rkIEbbragVMSwCj6r4GNDgSVPBO1PJ40G8I8YFq8UKtDKliVwVigOKEUCD+VRFZ/3PPJv0Ppq2TQt1FnXWWentJdKEBfiGmjNQ5tmEbdPqzKqqtZLGARcc49iTiwk9tRZiiCyXC3bjhpT3jHlPdsHEzAg+towpE6O1CzFUXBQODhasFi1NcGy3Pdt9IvqK04JrKrutmaG9BqKLuNixag/YXZ6T6kATIqU6UlVurE/Yn2Zydox9wVVhLIlUHNF3pLSjJPPOLroFm+0GKZUmjKyWR2gQ+hqIBzepqScXuDg75+xp4PzsCXeer9x+LvH+d7ZU16Gx49E3v433hcuLx1DhyfkVIh0PMhweekiVF55/iWHrefutp9w6eoHXXva8+umX+fpvvUXrB2p/yYuvfpFvfu19NtsN337rLm1T+eC932S19lycXXBxtWW9OmC1WnPw6qu8+NwL+Njx2uufJ7Qtv/yrv8aDBw+Qcc8P/cDr/Nqvn6GqPHhwhtaRB/cTjTOgQrusNNGzXB3Stgtynrg4v+DG8YJuUlYVmmlH1R2P+x1jK7CMcGON6yJTzjRJqKNCrGRRzjcjN47XxFDAK23IuGgIoyiOWK/IaYPWytgX0njIk3sfkaYzanmfKAUlcH5xRS02Ujk5uo3ogs3lBaobFLNslVnKEWoDPlIruJIIWnDVZFKqhToXJRcsIKbWxtKuYotKh7glnowWwUUj5WiuZmFUW+rVknBOaRu1IO2aQDIxFIJkCAWqUX22m8QwZpBo/lW3xDnHognmYKoVVUdRqMmWfsEpjROmnBlyoQmBGBxDn1D1ROfIWi339vs8PjYFzuNwRXHfgywXP4e5gD1hrKWsCNKG2QGRibGhiLJoOqoKOY2GLFelCPMJr1BLwrvwjOGu2Dp8HHfUWgnV2lVxnuQFDzTOhq4594iAU7NyOefROlHzhNSRUmy2kNXRjxM5VaiCOm/FNieGoVAmj5TIsnOI96SxMI4FupGuGelCR2yE1doKtZaBoI7GV5bLSE2Jkpbshsx6dUJOCVcTvipheQjz/MTHzsz/w4QEz7sffBspypgGuwd6j3NLFmtPGbd0bSVhfLbLy4lcOlq/otQtIXaMU6aJC0K85PDoFqWu+Mmf+CkOj15g1XW899E7HJ8c8cG9h5w8t+Sjh/eQkoz2wg1u3TjghZcOmbKQh57OO46e71nFyuHtjsMbL3B8AEfrjr//pbd59GTP48ffwY1Cv/+Aw2PPfnuOcsYHd9/mxRdus+sTQ/LcvPES63WHuMxHH77Lyy9+gldeeonTR084O79kGHu61SGVyrffucfR8Qvcef4l7j94RB6E/X6DLjoO1h0qwuHhDW7fOOTxow/ZnhZePVpx4zOfQdWx7XcEhNQJ+SiijYfGTtfBGQ16lEztKo2HtoVhgKtNsvxRZ8EMw7gll8x+v6cNK5rY8eT0CUM94PlXjmhXS9LYsd/C+fk9Fi4Ryh6kwYUDrjajQROkImRUDIRQZ0dQSnYqi80CLZ6pbPFUhiETfaVtonU/OlGqxxMsrJyK1ImSr5CwpEprSHKYRzkToOQ80TbOQs9rxrWWMt/ve2pNtK0SfSFXKCVwUCP9YEsMfMMwAdOGkHvTTxZLqlOFPNgYybnKcuGJMVCrHWBqtbm6CYQVqROqH3eZiIKKtz/MiVRVFYoi1U5Yqo6hjLQIjQo0Ld672dpl26Fx3DMiM9TPti7VW6Gs2NdSLXPiuQ1YvczbWixAuomtIX7EdHBZFc1pxo8n0+fMYTbISAHQYoQSGsahkCc147DYBmqqxua6XsmHxjR3jkRoM+vWOPbLbgmuNfkLE9FHXLdGiWhTKfuesXq65gCJHcujA54+fcq4O0dKRlKiaRqWiwWlVHbbLW3TMpYJkWTcLzBtH5UhTZSSoSh931N1Ql2h5IkpF/bbnsrA5cUTDo5uc3b+mKvNJf1+xyp6dNvx7v0zdJo4u3xA3l8x+Zbz73xIIHJyvGSxOiaXiTRdMW52NIsFTWhZLA/RXHj48CkPnryN00jw0C4C9x+fcXq1Z7srfP6119gNjqebxAff+Q7P34xsPHz9N3+LF1/9NK99+lPs9yPHt25x//EjhjTx0YOH9FPk8dMzsu74yZ/+Z3h6ccU73/gm/eYJn3jxNm9/600WIbLPyurkBm6qDPuI75R+OKemHSlPLNYNZ2fnXJ1d4UKgPQzgE6vDpWG8XKWoMQanaTcHFjnSMBGXDeKUW3eWXF1dIs6z6wtjX5BoDpPNbk9wgdWyo1u9CPUOzh9zvL7N+VlLLmeEpiE0LYt2Sc4GD9Vc6JaRmvfkMRObhtB4prGnFvN1llKpU7Kk+VrZp4FSla6FKQ94F8nqcC7S9z2rw2buTIRpHFiEBsX0c4hZDsUBFNoItSaqKE5axrTHu0KIkAuUKVKJVFdN4RA9S+dISdj0o4Wk49gNDtGM84UmBlxVqnPkqohTggsmVvaecZiIvrLuhNgEhmkk9WKHie/z+HgUODEsyjWh47p3VDWBrVOoZMTbcjtVwadCUYxnVYTYdIzTaMXBu9nobfBJmXVyYMjogp0Sr7NEY9OQSyJcJwjV6xlGwjmZsz8zWZNZwdQsL85XcjEaqt2pLK9S1cKqS86oOPsZJJgdLRaqwCJaS1DySNs4urjGuYj4DiTNy5aGJHPakdn9Wa+PGHaVT33yVbrj53hy+U1kUSm7CxpXmKYNy9WCpxcbmsbuvnkcKNUWOWB6w3GaaGKHNI4kitaWime7ucQ7R9sECpl+mICGkxs3uLi4YHVwwOZqQ7do+ODhfRYnt5hq4dM//INc7be0HppU6LoD8iBclXMODzvGqVBLyzAo+6srVl3Lhx+e0nQe1665fXPJt995n+liyW478SM/+Flefv6AabchLjv+8z//czy49x5vf+MuUhOHhzdoO8/Yn/P8nRdol8ekqWVod7zx2U/zzW99g8SWz3/2M6wi5O6A1155nVLusFg0PDrdkHLlj/3Rn+Dn/upfoden3Ln9Iq+/8VM8enJJDPe5ufZEV0l6xWnecefGCXqghKCUMBB8h6sVCZYNkLPQBgUq2kSa9oRxPCc4WIQjnJr7oQosuhYhMQ4bmkWD8x157Cl15Pz8Lpw/ZOj39Nv7XG4umQ4OGbPlBd9cH5HTDqmBfd+DeqOKVAxSJMKYemMbug5FmfJEKiBExlSQaAeDVEzq4qTl6Zl1CU1omIaKk4Fu0ZLGCuoYpj2xVboOYpNIuccLjDmDOtKgeK+0rbWhw5SQuORgfZNhHNltLGCImgjM6gVRigpVK16EGAN5qlQnSM3kKZuUJRdKApzRflOfUK3mpCkf8wKnqpZcned2UgreO+Owu5nXKZXoLcxZZ3XvdbgzzJo2kWe2FLEQvdnlDc6LadvURI7XGQrOB1KyhYBhXhLeh2fOijIPasvMzQJ7McAiClO1lqAUA/TJNWcOQznlqtRUyHUGLAePo1DTYP5UiYQQqCHOGzpna31nITVl5v5rgVsnJ0ylwdeJs0d3Kad7nj9ZcXp6Smpbk4XgGKeepvEW0iN2vHcuUH2mVhsYx2bF+uiEBw/uM+wH6jSBq5Yun21grNXbzEQhTaMRV7AQ3ovNOQs3QNegZcnmas/V5Z5Fo/RXT3n1U/CZz32ar3z9bXI84J2PLjk5eZHD4yMWy8LTJzsQYRwHPv3pV/jGNz9AdcHBQctn3/gMP/pDb/Du22/x5V/9FYZhy/vf+gZXl48oZUJQXnvuFVIJrFdrloslN05WHB0cEpZr8IHD41usVgt+5Md+lP3mijfeeJ6zR4c8eHiP04uRH/vJP8JnP/MC9x48IcvzvPKJ5/lX/6X/CT/xEz/JV3/za3i34dd/6Zf5rS9/GeSCPF7SLj/DUbPAkfF4olhbZSKm7+ZzijPqTC4wlBVtd5Oy31CHnmbZsVjY0my7Nfvc6VlC6gTiWBy01FwYpzOuzk+5unpMlkTaVLY7yzPod2d4DM0fXUXEchGYqdJG4FELRxJw3uODSadqKUxTpo0N1Mr2aiJLR7doEA8FR6qZ2Dr6YUdKyayMqtTi6HeJNkQm3SNOTXRfK84VxFuhq6adt9xU17O/+ADvHFEmis+0wXSluEAudmNwrlj0ZcVYclqpRdinkfXKxOFVPfuhsMmVqsKYZ/WAfsxpInMFm5cAglM1Bb+adQTvTQ2v9ou2qZwVxmshcK62KZ0lczg/e+4AhzcZiBMLqBWsXRTHlPLMiTNbCM50O0JAXGPHSKpFnBVmcXCgSDUfH+Zl9cHNSvGGXIWUDOlci5qbQMTyIQDUUtudChLbOcXIwna9GJbZ/Le2x23bjhpsgL3fXTAOidg2DNP7TDsjVywP11xcVRsU42hdxUlmHBNxXtqYBU2hWAr7mIz/1XVrhmnAuYHihAlHqZHQHNI0h5BHTh/fYxo2rA9ucPPOSziJeCoyVh4/fcgwXfLo4T0WfoFjYN8/5Lfeehdxgd1JS3CBabvgxss3+ODuGR9+9JTQtLzy6nN8/evvE6XltZeOeOOzrzCO8P/4v/8cdz/4NturDzhYe6hb+v05TfRUFT54/zt061vsDwu+aUgl8NzzL+GbhjFVDpZLYMH9R+fUMfHwwze5ePqEG7dX/OSPf4GXXniVf+6//RN89esP+OCDC77z5i/w0Yfvc3Jwws//zV/muTsTPhZ2w5ZFJ+y2PfsddIvAerVEfKJKNZZgXVHVEdpCUg95Air9eEEVk0bs9jvICbdoefJkh+CI8ZDsEj60xLA214F3pJo4O3vAuLtAXCX6zkY4M6HEB8eyXVBTJo39rHHzjNni87SmOQJQmEbjvRVVhMyy9XRNZN9vaA7sZuBdRxM68A4Vu24p1nqXrMBA13Z0TSRnox43DbacKAUvhXnvb+2oFqZxIueRWgJarXCWaqOjGKGmYlrUYqOonJUglq3CLPdShf1o4ArxgUlbxtxQNZLSZNZN8rXD8x/5+FgUODEaokl5RVCReQtpSCLBchmKM1WFF2f5qDOQknmmdJ2F4H0ATeACENDqiU2HbyJpGmewXsbOWWofhuGXRSJKJngTy+KU4Bd2ygwCLtoLWi1o2TdWFHNOqLZ4d4ArmVouUSmGVveGZY4OuwB8S66FMhdnVPFVSXlgnHbcuHFsRn0HiMUn5lJmvIyyPlnSti3p6aUtXaKjaSMHuiBNDdvNQMomS4BEcAPdYs3T0WYaxrav9LstqBBDZPQW8+Zm21pJlTTu6dbHaIbtfoPXzHZzysXlY9t4x47PfeEGr772KX7zq19iGh6RgmMcEvWh4/jGy3z+i68x9Uq79Dx9cpdfPTvFxYB3A8/fPuD8yRNcXHB0q6XrJt5/99v89b/+d9gPiSlfcLm54lvfukvqNziXAIcPLZebp8R2ybR3nJ0KLzz3CdQFvvHmm1xtttw6PKQLmS68xDfefcyXf+UXGJ48YLVS/sAf+Wf46X/jJ3n7Wx9xvBZef/UWH71T+Rt/7a/yl/7Sf8aQ9qzaOcM0JrIrlHrIYvESn/z053n8+JvEA9OzwYRo5Gh1g8vdBjvh2/VYsdT4J48esgwNpUSmukD9IV1siWGkbB8RXaFdeK52mZIq3WLFwcErRC/0+yeILEi1UsrAYrkij8LlmMyNUwzfHaInRBvNVFVyqaSpmB5NK94nVqtgZGwcse1ouiWrdUXVbuQ11e8Gp+OpqoxTomkD3i8pOjBNG4ZsiVuhNWcCKG27BAkslgt2fQ8RDg5XtlnF6MZMlZyEOlU7tMxF14tCntUMJGIQooukrGwnz1iFNrYsuzXj5c78rvNpObpK+J0UOBF5BfizWO6pAj+rqv87Efl3gf858GT+0H9HVf/K/Dn/NvCvYYLlf0NV//o/SZETrGipmvTCWTKHOTpkXhRcOxuEZ1QPG4Jid7gQ55OUt3B7KofLAxPgNg2lVIIoOZlbIgRPRXDSERdH4J2tv+c21NDaS7yLNF1LKokyXkDJVFEkQE7QRFDtuH3nU9x/eA/8HheNi5+rGIQzWwRaqRC9eyZFCQ57kbxnsTiwp4LN87w3HyvFnrcjUXJmN+5pvWcslaZrLJeVuXDLvHkOQs6WN3l0fMTZ5X4mIxu6WgFxHoiEpiX3Bh5sGiFGx7af2F8+ZBwnctpTqs7PJ+PaBWjDhx98m66JTNszLi4f03VL2m4NvhL8hm9+/VeJYcXjx4+Zxomj4+dYrNd0XSRQuXP7FcIi8PjhR/y9v/2b3PvoA/rxnBhafteP/zS/68d+N7/51d/gG1/9Fah7ulXHlBLLxYIYKsfrlof3HiCfL2w3W17/1CcZx4HN+RXvv/stQlxy0HpiK0ydvV7Tfs+v/srXcRRu31rx4N4DwHN29j5T2rFct7SLyOnTC1ZLhzSO6iqhjcS4IBfHwdEdgl+Tpj1HS+Wll5/jN9+84nI30cRgBvGkuApNcFAnSoFcAqlGtk/3eN1S844mTqSnhdXRKyza5/mRL/4Uv/mbX+Xu5UPG6inJ8i3CPK6IsSFXx5jMqeKwzAsfrCVV7P0f2gbNghZlSJl0Nc6LgEAtyjjuSFOl7cz+V1JFSyVjhSs2kavtlv0A42SLt671HB6sWMSOKjtiMCqJeJO9lJm2651ZHoOPaC3kaTDQhQaopm9Vsa2zUgx3VhUXbRGHTkQpLBeeflLGaaDvjak3JlMxiCgej9b8T1/ggAz8W6r6GyJyAHxZRH5u/rf/SFX/N/9AoRL5AvAvAl8EXgT+poh8RlW/f/w0WJs4m4OZ03ueFTixAqi1on4OCZtDJ3KxAWgMgnegmnAugne4uZUdpi2SG8rerCq2ZHA2M3Ge4BYsF89xfPtFxlro+y3RFVQxkqwI0+RYLpZcXT2kZodqIpMZ+hG0wQdrRx89uUdolbpLlFoN1piMU3ftoxOBOBekMKOO8mRIJucFxOZwFctkqCWQxgyiLNtgPj0JFPUsZ4yMlkp0yi6NiK+0XWSYHE27YBzgvQ8fkhFwlkBeqrNQYQm0i5ZaT0jjhlL25NJTs4UYn1/ZKc+5QsmWKJ5K4aWXPkEMCx7cf8iXn95nTD3eZ974zA/w7XfeIU0DF6f3SHmka5ezLzGQ84JPvPIqn3jlVU4fPMK7p/zWl9/mo4/ucu/eezYjdQW/WrO5eMzV1ra/xzeeY3v1hM1mbwenhQ3Ya31K07Q8eXSPYYKmW3BwsODo0ICg33n7a7SLyPM31jzYQfBK1zX8f/7SX2C3H/mpn/ohlocKfqKfhlm3GLhz5w7bi3MadaybNTlVfvXXfpnVccv6sONqc4VjINTCrvZ8+NElTQiI6ykVVutDqo5UFUqecK4YJbe/ok/gfcM0TcSmBd8Sw4r9vme3echf+6v/JSlv2E0DIZ6Q6pbolW5xzNHRC5ScSLtTQoxMU7HNfU7WAblKCNDEQIzORjUi+NoxpkTw1XJ0teBqoOmidRO5mGfVRmqkwcJ3TDbQoBKYitBKx2JV8LmHKmw2e5zv5ln1nJUgLapKmipVYNgXxLUWiI6J8MV5g3IWUJ2IwaFewXtEKlIzoo5GBW08ecqoCEMZ7aY9qyUUu+n+Uxe4OfLvwfznjYi8iSXVf7/HHwf+nKqOwHsi8g7wk8Df/76fITL7P22+5rwzwoe3OQKz08HPCwdrR+2UUgRiCPPRb94+SuCa7hFjJGBDV2Yskw92t3E+4qOHGlksTdhZp8SoiaPD5RwUsqJKIo6wubi0Ni5ATsUQ5TqDAEsiiKffPKRIxZEpFbQoQbzJX2qxtbqa1WThPW3jmOoeDbO/Uayo44y+IDPr6lrq45zn8HDN2YUN6X2w38802puoaR15GOf5pJGRwc0XUzFLGTYLaSTgY0PbRprgiL5ydXmf4WqgFOiHTNMeWciPU0RszklW7t2/x61bL+CisN1uqHnCx8Dd97/D7vKUsR9JeQRRyjTRtIHF+pDVsuWrX/0NfvEX/hYBYZr25FyIsWXRRXbDlqzKmCbu3n2fq/07TCmxWrS0wUMOpDwxDSNpmBhCYrfbcHp2n89+7sc5fXrGowfv8/qnP8HVxRXjdMkr60+wbpc46bi6SvyNn/sSd557ni98/lPkKfHw8X3SVFAKbQc3bx6jqty5/TKiFS9QXeTOK29QCPjQgGxR3SNS2I2O830P4lksllBgu90xpULTrNnvJkJMNM2SQKWkTBVsCdBECAfU2qGuZX245uriis1437bnaYV3ylQmltKhdcHFxUjKnuqKnc7GQoh+JlHbiWoYhXHKCPYx4htiaPEOvLfIvbHP7IfrBVuh5owXx6LzdF1H0zg224FUGlIuUEzHNmVHI4pvPK3zpCmQpsqYEt5Nli07TcQYGEpmu50I0exeIVRcozBnnXZdRxodzhWgMKbMVDKaEtF3gDc9qZr7ogsLcJWcZgw7Af7r4sGJyCeBHwV+FYsT/NdF5F8FvoSd8s6x4vcr3/NpH/HbF0TAyKM2d5otIfPpzUJl5pZN7IkGEYLMaBcvVKe4uYg7AZVrtHnARImW54CIfbwWQuysXcyJ4Ft8sO2jiCeNex49OMXHBeuSWR0uiVGouqfULSVvqSbHphbLYw1eKDLazDRnSlFysZNp1oKWjEcpdcI5h6+zPQubNzbRUWu2JchcxgVBq8zF+HqD4rnabBHn6GJjy4xsmZXB2YXZDz3eCw5QJ+YKySNaFCSSy0BwniYEplx4ut2Qhy27/QU1ZxRP9Z6SW8S1BO/o99s5Ni4xpYlF23G4PuL2nZf4ra/9OtPYk3tlt91xeLBm2O/ougYXPMFFVDPnF2ecXxiUAM0cHx5TSiWlRC6JfhQWqzXeORbdgt32ktVySR63bK+2pMlAp651XG63OCd4FwjOcXnxhKpbmqbjB3/kR4lB6FY3eOnlF+iawNnlQLM+4vU3Pgc4zp+ecfftr5Gr8PJLn2Ic4OrinMNVZbk8ZL0+4vDgOS7OnvKJV1/haqz8+M/8syw8jFcPifEJ0SWcF2vdceSamXYDWgIQwUVSLsR2QVFl1w9oyTRhjXNLioxshz13Tlq69oSuu8Nzz73MW299ixomFm0gjRsur/bE5ojYdODghZdepd9vuP/om5QyEtsOkWrzLq3kXG1GKgZdVVWbcas5Z3IyaRRYYRwnE8vGJlrcZhDa1jGlPYvlGh0dKoWsmSkVxl7wi0AqIykVO3iI0sRgN9spMY7WRsY2cuBMKaBici/nLaQ6z0sREUP/B6e00SGupTpbTkxTRlyD85GcMz54hILzULIg2PP8fo9/4gInImss3f7fVNUrEfkzwL+Htfz/HvC/Bf5n/xW+3p8E/iTA8dHKCg/2QjgRU9urbSBtm1DncBjzqFbxBGz7abgkg/sZHsSOyirR5nLOMZObDehXK5ILTgLO21D47PwBPiyJrSflc9ARkUPKtEDTgjRmcppQvWbBYXMEDNWSq9m4noEFxZGLafeKVEiJXDJFKy4EFo3HifHonYukKc0nV9v8lppoQiRVGEajCnsqtVR8CARvxS2lkflXhfORgEMkkott1rTOWHfxuOCgVGIjdO3sl03ZNsDB470nj3XW+VUqgeo8eexNJpDnJHG1zEzv4cmTM4axMCWjGDvnuLi8IMTI4eENdsPAbr+l5HHGX02miFdl6zwHB4fs+z3TNDJNE+N+y82bt7m8uMB56PtzhmHk+OQFbtw8YcyJ/bCjabs5tLnYYDx0HB+vCWHNlBsePjnl06+9xvHJHbpFxMUrbt9Y89k3XuD2czf4D/6D/z3b84f8zO//cd744hf47Gc/zV/cXUC64OLiKSKOT7zyPLvtBuc9/6P/4f8AUceLd4746q+/R/AmFik108w35n6sM0fQJDo5Z5o2oBoY+spiEVG3YtAlnRa6UAih5epiS1osuXfvTb7zzlsUetrVksvtyLDfgTMTftaexbryw5//PKdPep6ePWB0hZon01TOujLnbG5dsQ5CxGEDIsF5bwivIdO2C9p2SYxGKI7RWIj7/R7vhIPDQy4uxGRT2FZPxJFTYZRsDoQKZRqhRHtfamA3wH5wuKYjoIhmShK2W8vSmHI2lYJYV6O1ANUC0mNHLsWCuEWZcrJZm4/gPfv9dn6eQmgi3imSf2czOEQkzsXtP1PV/6e9ofTR9/z7/wn4y/N/3gNe+Z5Pf3n+u3/goao/C/wswMsv3tJSTdnN9SzOWTitqg0SvfPWDjrLaajOo3ikCFIV1zgbdtohzWB+FEq2hEaqvVCgM6LcNHG1gnOZWq7I05apV6OOOpj6K1x1XF08MUJD7Um5p5ZEKYmcmAM4rBVUVZxESrZkIVVnKWGzH9VY9C0Foc9CWxXnlamMhKZBlXn9bZmhOSVqnkF/pm2x+dycJZHGEScQYkSjoZl0qhyf3GSz2TMOlWlMlGJeXQqIE3wIiA/sdnaxLLpITo5mscS7yrgDnSZycGymRFEbFscoFM1MaaIfdpyePeKNz/4uNptLHj7Y2HJDoZRCrdA0K154+dN8ePc7XJ4/sZATG7ECQj/0Jkqd+vmaKIzjwOnp4/m1ybYoUuX87DGbyysODg84aBtSquShcLBa2c0mw+lZz+uf/iRnT7f86A//FNI4LneJbU7cvn2bt3/rG/zl//IvsL24YLcdWC4dv/Tzf5tvvPUmlEj0havNhqvtGTEIjx9/yGrZ8f7b7/BnP/wz/K4f+xk+PKw4/wR1I+IiXjxTSohTmDN1VfL8GiqqmcVigWpg0QhTypSyw/uJtl1wdPBJkjvg+OR5zs4e8P4HX0cYWbklNQpNt7DQo9KzuRoYdxdcPjxjSgHVweZupnyiCY1t3FO1cOWZyFuKzeGceHKtNCGyXLS0bUseFI8jqzL0CXENpUYut4WhZJw7NJ92rTTe07SFVK7QKc2yENN3TjnhPEjoqC7gmyW7fjCVQA7UEmibNVJHIoGsgVIqsekQV0nDgGIzdS8CjcOrQhfJxbSFTitda8qIqkrO2Wyd8XdwghNjhv8nwJuq+h9+z9+/MM/nAP77wNfnP/8l4P8mIv8htmR4A/i13+57GLfD0umDM7EsGLIcwTIanA3lrRW17aOlINiM6ZoNpapUvc5XsLxUUcW5eZ6lVgFV53hCjWgpQCZeOylErW1KO/K0xc3G/1rtc3KaqLOkpWRzTJRS50UC6Jz6jauznEQpucwiZA8qFi0YPCImJdCs4KytFolzqzzZRqlMlng0Z1fgnQWg1Dq7PSayZiS2Vnx6W34YERm6psMOdI7NZst6eUCpsFweUfPAerng8nJH0Ug/CaUGSh1wjHS+AVmy25syvmIiS1XPNA1sr85YdAGh0jQtt27d5u7dD4BK32+5f/9Drq7OrbjptX7RXkOTv0x475mm639XpmnEe7sOSralTNWJ0LTWdqG2IW4cQ78jxIbnX3yO5UFLlcztO2sWqwW7lHnh5Ttst+dcbnu2aeLx+ZYynaOS2WwzX/naU9pvLbh95xO8/PILHBwuuPdgRx4mVutj+v0EEnn/ww9pu6/w+c/f4OBwS9HGcjZqpvGm/TIUVwYpBF8AR6qVqYys1pXgMiXtWM3z5V1f+F0/8cNcPC3004VRfDtlvbzD6uAOWUd0ipydXnF4cJvQtpRU6TcbpnRJNQwPotY1FLVRhQ8RG/I5fPAz083N2jJ77VJ2TNNImgoxNDTdGsnm9EEc3lsodpUMmu1ay5lh2rKOhUWDdQg6zfPiNcoCzZWiiYPDJfvNyDQpi24JaaLgUO3mhWJDK0KuycY30c92SSWnStVsGSrzrDKXNIuN7T1tCXsTTgLp+9e3f6IT3M8A/wrwWyLy1fnv/h3gXxKRH5nr0/vA/8IuXv2GiPznwDexDeyf+sdtUAWuRW0mdo3BHAwis/qjMk0J70y3FoK3CD8xWUjB5BcOj3q1jSuZmm0GUefN5SxEoWZFGZ/9W61KlcrhrSO22ytqrnYsl0JRK15VM2jBqa3dy1xcnZpF6xqhhAghtKRpssEogjNJrM0hqs4ggYakFSmKlMyia20JkiC2DaFd0/dnRC8UHZFsrUYqSi7ZWtUZoVRqRetImRKaC+MwotVZApRWximhYmEiy+WhzewIqDTsthdsr7b40NGoozm8wW4vhugfB3LeMkzeipIPNC5QstCsGh49POXR/V/ASO2Ofuj58KOPaGKDCIzjlnFzjnfyj7gIZS5mE4eHh9RamaZp/jdbBtkmfdYKCpT5MgqhsdcpTXSdyQY+ev8+n/3cj9IsV+yuetrdBYvVIdSR1197mTe/dY/f+I2vsGpXJC6YJDFmRfy8WV0UpslSuWbDEyfHt/jMZ77An/8Lf5nl0SGLg8iQnrLIglPTbIlz80a/2uusrV2fYGMRLJlNy4CqhaYkDIa6io5vfuXnydmTwx4vkZP1p+jWx2x2O6Zxj6YnHB20LNaOfaokyYRuwW7c4qMgube3jlfjEaKUpJRZX1bUzdo3Gy9YEfbs99OswRQrkKUyTTa7m1KCnNASGIYBF+alXk60mqlBKGLoJC+BrMJUHEFauqbBy8i4j9y88SJjv6PmHYt1RGnpx0ytHsFR64SokuqEk0pwJg+TAgHz8SZVapps3DOPlGSWhHnvmfL0O8tFVdVfvK5B/9Djr/w2n/PvA//+P+5rf+/DO2fLBZmBdiXbogBAFB+cceOuT3DXMMqcEWcEjSqKVzf7F0DE45nnSa5iO2msDfbzHa1aslbRzPn5GU1jJNQyDahzTNm8frVknJuLKAGdA6JTGlG1jNCUMxIKU+4N3JcVEMSHeVJnT0hRLLTkOtwGdvse551tckti7C9ZriJpmpAQrUlVDzhqyXZrc+bDm6r1yl48XhNBoC+JXB1FHITAcrkgp4oQWK06mq5juH8fHxYEbxiqYbdjHKBb3iCEjsFtSXUH057GG8xzu99wcHSE1MpFtdCfKnWeOwohNmi1G9I4bYhNy2q5Yhz6Zyc0e20A7OSx2+1Yr9eklLjO4XDO4X1gvT6k7/eM42iIn1wZx0wule12w40m8uonXiY2R+yGiXJxiSZhuzkljwN3Tp7neLnk7Mklf/gP/jRpf8Hf/Tu/SnV7CpeUacs4TYxT4fjkeT744D61Vm7euc2H90/56tf/GrQdByc3oG5wWtAcwHe2zccCj9rW5r+lzgp9jJBDVkKMlt1LoWlg0kLKSvUdu3xpp1/X0cVjnnvhU3TLWzy5uuTh48zm4hQJHqlKKxOOibiIOOnY7jeEMHcy1Wg5sYvE2fkjznD9zvlZeWAzY3ENLlRKHkFhHDPIQNMc4r1j1RwyjiO71BOiRypAwfkE6hnVQzIyisNTpENCIXpP29zm5ObLnF1OXF2d4eSC1eqQOhZWhx1VnzANZrcTHUES3tu1Y9ixMhv6laJl9qibEsISwWxWZ1ZLh9N2Xsz9ox8fCycDzHVnLqO1FHTWuYHMW5r5A+e7ORpQzMbhPIiEGdWNqbu9zHcJWyyo7SSpVMt9wGZFoop4a/XKUEjJUr+dD/amqqb/cmLNcFGhEKg4xmkADI2ec8b5aE+kWniGZWjaqbNcp3ej4LFTp1Zrl6tBBFxVSAmdLAvSidFSgnjE2alBfKQyMU6JaQ6VRhUXG2qNJDJjHqhY2y3A8eGxQT39QNfab/vB48eUnAmNUFMiDRMp9UzJckqTQtUAGDJ9s93hG4ODXlxu0DTigzcaiVRi4ynZcEuzpx9mCqudxsRmgfMY4XsfOWfGcSSEQErpGR7+WkN4fHKDod/R7wcLknYR7xzL5ZKrqys2mzf5xKc/zauL11kubnD/7D7vv/tNbh7foNYLUlYcIx998C4vPvcyP/hDP01slrz97Td5ev/rUM55+vgRn3rtDXtDT8KDh+f42PGH//C/wMPzLfv9XZArhiHRLRKtW6OI8UqdElw1LVpxxMahJILzrFcLatnR+Ip3lunr/JqjGy+yXL3KfjOwvfyIIBN9f8b9B28SmyPU20koeI8SqRkWTUPQzJSvUE2ImKg7pURsAzl7FAGJFHEEGtz8MeIt6UrpWC6fQ9SzuXpC0QtyUoQDciqklBHczG4TC3XSGe1VHErLfgyMQ8/xYWMn2FppAwQ/sF5FXvnUES/kQp3usDkfyXng6HDFu995k3F0BBlRraia8R61raiTQoyepEJKdngJPloGijhCqHYDqdko3TXgXEPO6fvWlY9JgZuH/hgy2XIFMMOw8KzQ2ezNioctTC0cxlpZk1GI2hC+znOaorPBntkMPbsbSrUELIMez/ozIFfAObtrSZy9ribt0Fpn58RA7FZMCaOYisPN0gen86ZJZwR6MUiAYqgiHwO55tlmI1ag5Xr25sjFNmEhBNqmxTtnA1y5zqaY5yQ6Lx9mh3IaR3C2Pa3F/LGOuTWRytXl5ZwzUbm86umHYtKRYUuaJoPoq87BwELXLVCNTCXD1BO7hnHo8YtD2mZlCCh1dIsl49RTUp5F2vNxf05o0jlbAwxC8MKLr3B4cMK7732b46M1jx49BqDv5yQnkWegg+PjGxyf3OTu3ffwTmmaBqSw21/inOfmyU1u3L7Dfizs+8rd9+5z4+ZIYUQl8eabv87D+8d842vfJMaW3fYp27N7/Kk/9a/z6utf4Gf/07/Jz/2l96kMlJrZ7/YE7wjeoif/+B/7g/wL//x/i1/58nv83F9/j9wXxiawc0pAaReJblmIknC10sSI8/M8Mq4Yx4RWIQRvHUgVYrvAh1scHn2a/RQ4OFlyufkOhcQrn/5RzjcN26sH5PyUqY4sl4fcuf0Sr3ziM3hazs/OePL0I8an7xHCQC6V6KuJjNXkHgZJUKpvODx4jvVyzePTBwjKcnmT1z75g0hteOubX6EvPT4MpLSzwPSq5GzFuYDN9mqeRfEHIAEStLHgXUKoOLW4zZKV+w+esB8PacKK27c7Li8fGtm37vChIGkEnUCNS2cU4ErTBINTpAm9pot4e73FMYdHWZh1bBbkEqhi4TS1fv8J2MekwFmwi2h91r6Ziuta8zpvDuetKmpLAnE233gmv3Z2KvM+2Jp8lmsg1r7KbAGzdbbx3hCZT48elYKPRgk16ZDlPZScyLnO+WmZUjN5XynFUQnE0Frkoc6zOtQKEjZTDLElD3u0QnTWMsuMd/bem6MAh1ZrX6va0mVM1lYIoFKYpkLVAReWjGNinEaa6CjJwmaQyG67gZrRYnq6xaJhHLd2B8ez28NuSJSarWC6SA3QdWumaSCkcd7WBlSEbnVAqRafODEy7DaE0NAtj3np1i22m0uePLpnhdYVAs1MW7H82RBNKR+ipxb46Z/6/dx57gXu/l/eox+GuRU1InIp5bunO1UuLp4yTQMHB0suzi9IaSLGBu8DNVemtKRdrHn5tdd45zsfkMuO1cEJnSx4663HVN3xyVc+x7vvPuL06UO2u3OcKH/6T/9p/s1/69/m4vQh/+x/95/nb//8X0SGC6Zx5MUXn+Oddzd48bzzrY+498E93vrml1k1PYtOqDmzuQDvJ3xXqOpslFKczZKi3dC6tgE8QxYoSicBLY4gKxaLY2J7wEp7zp68yypMLNvK0aLlznNv8MHdTNaV5coSOT66we0bdzh9fEqtl3g/0MYl+92I980MUoCKySucL7RxQfBLmnBC1gUiew6Whc997gepteP99+/SLBOlj4Y1EgtzccHZa1UzdbaIqYu4uERlQS0ZlUtCyIiUWS7kyNXRT5Yr8uTsHcgF4QUuL55y++YJjx+fUcolnh51goodMkqtBG9lqJRZ1RDsvWGdULXlHtaPqAao0bBks3/d/zZV7GNR4Gwgayn2ck3zVSsStvmpM1nkez/juy2o81bMbKg+n+Yw0kPwgZTrvLmRueDZRWlD1jqfWuzuUHOw718ttxEnFjIjVrysxTVoZHAtFQfVkrkNl2PAQ8TPuRJiYswm2txPKk3bEJyj3/eIM3ihFXZwYptWCzmyi0ecULNlA5RqaKj9ziQCXh0plXmOuDcbjBjkMzg/t4hGFaka0VwJIdI2C3bbHSF2BAQIrNoF7XLBsO+5urpgdXiTcTzk6mrLYn0MfklsIk9PH3JyfMxue8b5xSVxscKVSM0TkGhDw+HhCQIsuob79z40zWHw3L37IQ8fnzKOiZxG4DqvNvIsAHx+qFb6fsduV59thMv8WglCLoU8FQ6WC37sR3+Qr/3mN7i6hFc+8TzHy5vsysBXv/IVNpdXpNyTFWL0THngcpt47qUX+Nxnb/L1b7zAxRMBjXznnYf4sGJx0PLyq8+x2Q08vneXphlItT4Lnhn6TLPJHDYRjY4hJ6p4Ggc+GkCyYolQOTfsd4nl6gjnn+dq0/Dk9GtEGTlat/j2gIvdE/zpR9wKN5imypQG1gcdOiXOHj7gw4/eoaTCOF2w6weGseC9ImJdC1XxruIaQSTiXUQEnrt9zHr1CvuLM1QvSKnn6emGzdVTijym6kD0ZsC3/GRv2Q5VQU1gqxS02nWc8462yZTq2e4yMZqRumpAfMuUEjGM+DDy7vunlAxXm3ss2hbxJohXQOb3SplPiD52RO8JXhinEe8ga7GfA4/Wa7ajMymWFlTLvMn5r8nJ8P+3h4BHZv2azkRemZcK8uxjROyk565V/jqfwNQyHmupNrOoE+IdJdt8xIvg3DzTm5O+Td1dzBFRsVOgOjuk1WpFRwwXU0uddXOWoSoabB3vIq237SfzCtsaX2sxi2k4CGHOhRRBxAPeDPjtAlTIdcRR5yI9B0mLRRaKKtMwWXPuG/JY2fWXOC8Eb0wv5wNVhWlKoMa3r/OGrG2WVrBDIGXh5skJT5+eMpXCeh0Z+4EYG+aOHa+CSGax7Ay3vRu5eXKTECKX25Hzi1Pi4oDzyw2iQtc0dIsVwziaA2Eh3L79HFOy9K+HH71PzvtZ5Atn5w94+vQMSDhXMW23Mo7js8vBzadcmK08KZFSskG0OJomEkNr7LCaGfdbDo9eQmTBd977Fqmc0TVwNvZcXZ6ziktqSWQtpKRsri74y3/xz3L8wqf44R/9H/Pf+e/9T/lrf+XnuPO84lrPtN+AtLz//ru8886bRCpNDJxvJoYcOFodcrA8ZrEoNHFiqntC4+nigiINfXE0MbBeLvFeSNPE0Lc08Q6/56f+GKkK3/zGt4h+4sOPfovqNzT+gKvdwOaDN5kmGNLEdp9xZWRKG4pL8wnfwlhiCEB+JpYNMVCzaUNxDRKh88Lp0/d59PiUoe4hj3z9W78FdYnExDiAVo9zEHy0zqcWKpWcCj5EaxerUOtELSOOnloLyQlZhTxFplQJfiTXpwyDRxpPaAuugTEbIbrpPM43DGkg+kyoRsf2TnFR7JR2raQQZwJlxRZr8/vLS6SKp6hS1Cg7zBbM7/f4eBQ41XmbaW2NOLNTeWfIFodZlsRbMdOZMGL+NI+WioptVqpO8xukQYjYyj8hWrEc1WLFQuxY30+J6LxpraojY+ldlgvBvNGb3QlzPqnzHd4HM/WrFcDrjMnvauaSDUe1MmbTSHnn8d6iB0sVfGyY0mjt9vzmFWdfy+y4ztDm3jZfKVf2/TjbbIRxzPNM0JGykorSLtYUEtSK+Ej0C/qh5/nnX+Tho1Oenj4kJ7OSlZLoFi3iPB7h8vySlCbWywVX257zp48tK8PBMJlg9PD4yNpRSThN3LlxzOMnT9hMG+LqAK2Ood/y0UcfoSjTMBJDZ7RjCnfvvmuzU+w5gkCFWuV7dHL6rMjt93sODg6eCalFhGFIvPj6awz9yN0P32MYe156eeTmrSOWB4UuBk6nxH4cKZJZHey583zgvQ8zKVlQ0bvvfpsfbJfI9hGnj3f8c3/09/O3/8aXSLoidi1tKFye3yO24Bct6g6YesUHIdOynzz5cqDUwo2TSKSQck9sHUELCwnU/cDy+FWu6p4mFpwvaJ14+OE5i9az3T+G9oxaJ6YcWVSPlB7fRJbtEUE6UrokTxN5mPARqJnghGmc39fzeNrsh0uUiHMR58xWOOVKrhs0dEg4wLuV5Z7qgPMHZGedwJSLSZawoKI6n9qqFkQr4hJOe2KAxWKJ6sQ0TVQxbmJKoDRQLF81Z0A6qhS6xqPOskoacc86LHEBJ5mSJ9SB4KmlkpPhmq6fnDiLGSjFU0uhlNEWLM6cFL9NffuYFDiYC4oN/dE5D7UYAPAaailYyryVGUOT23NzQEBwSFXqLEEwFLlp4Gyzd00H9vPczgJmisyr9hkMiLPTmlY1bn1JOPHzIkShOIsJdHacD3OakS14rSAWLJpQxOO8t+9VKyE4ckrEECnJSLp+XpErmHoftRkYWJHEjNPb/QCuIYQFwzgwpkqpdveNbUOpPT62LGRJ2vbkXGmjZ7lecfr0FJFMrQOO6xDeiX67RQiMw0CakslFxsIwZtp2jVTh7OwJrvFM48A0bU37lxMXm3MuTh+Ts5FTrtKOmpSnjz4ykWYos7G7JYTGXBQeUk62XHEmDypVGYaJlOt8U5mvB6zYbXe7+SoWmrYBHGfnZ2Z6d45XX/0U/bTncjtw/6MPuH1ywPbqjOOjO2wkcuf2ltdfgxs313zt63sWywOqVrbnj/lP/s//Ma++8cP4/jMcHiz51Gd/Lx++/4h3v/NLdKFHS8Nmu2caE42P5FRpGsvbSHrA5a6njT1tVAgJR6KNZq3aTXD3wbc5OXrOhMDlKV/69f83kheksseFQusaovN06zWOgojF4TmXqTpgS6UO5ysqPSIW+9e2npwhFdOHxhBo4oJPvvoFzs+uuNy8i2ACX5cborRUIl13g91uROue0AiahOViyTRk8wWXSq6gajNF7wWKGfRDY1YuajBxrmtIdTKQBDIHspswd5oEH1YcHS6Jck6ImRuLNdvNU5zLiC7QYu/kEDyodSGpKgTzZ18v8MTPpN+iSB2hmtunCgiOED/uRF+wU9zcgspsng0hPCsas7IN5vpvCTJGCdG5wHmdGYQuoM7azeDDHPaCLRu0Wu9eMPJt0zCmRCqGZm4XneUs1DIP+JXgDbDnvXsm2GWeB9l21bagWiuIzm6KDJjP1exmgkhlmjLVB4btSJiRUFVmSnG1Iul9g3ORnGbP62Qm51ohhMiQTYDcdSv6YUB8wzAmShV2u4HDo5s8f3iD0ydnbHd7LAPWseuvKLnHEShpz5h7tDC3ICAuk6aBcUwgwlSFWj3VtQx9P0tmCnkYKGkPNc08/fmlKTonM2WaxhODZ9EKtUyM48iUQWuLFjNJ29xTLQ5uHSgqDMM4B3gbdRhsCN3ElmHck1Pmc5//Art9pWmPEK8c3bzDw+/cY7vPbHeXbLdPiG1kvXyRZepQuc+N25HXf+CLLA57Yjzkm9/4Buf7LU32fOftb3H76BX+5T/x+0i64N77j2mCzXtymR0JJNrGsVwtybkndIf0xVNKx2afWK5H2gBaE6GJuBamMTHUgV62tN0xtQbwGxr/kFUnTKNj2k5439F4nccsmaQTy3bBJ176otGdG+X86X2+8/43KGxxwebVwUWCvcutkEml310y9DsggF8QXUCdp9aRXHqaeMBF3hhFunqUljSOhOCM6luUpBOSFS+VqgNCNgoJYY7ctNbYq59RZpaChRaaRceUlFV3wtW253jZsTnfs1450nROCAUJQs1+HqPYTDtliwKsasvA4Ft0JoWUWhAKSMb5ShQDHKhaJvL3zm3/4cfHp8BdH0fluwuE65mD99cnuLldVaWJDc4HSsnUqtdtOqBW0IKAFtDriZ03NbSbT24qFC3koTeNt9hyoYx5XrUzD11tJijqvjtwVZ5JIBw8gwSA2ByuVpwX/NzS2vfTWd/nnrUVbraiOYFSM0Hk2Zq/VkdKWDGbDGMTvSc0kZyMkuoodE2wBCJxNG3Dbrcnl0wU6JYt47CnpkzOE04n0xfOuiMycN0uyMzxn09ZlhLmLMCYhqxYlkPbUblkKANawbvCNaLHaD2Vo6ND+n5n0pWk3L7RsroBeGUqA1NS+p0yTfb78T5wdWWhv36ek2aF2HQ4J/zET/5e3n77babzB4zTyL37D/nCD/1u7jz3Oo8ff8RmO3J8csDZ6T1jAlbP6ug2SZYc3b7BF37gU0zjmwRu8YmXOn7lV7+EU0fXeg6ODvnM597gR3/yDZ48eo+vfe07PHjwHaLPVMKzeapQaDobbqdU8KmQMIfHtlduFkdT9nTLNcNQKSiLbsXT80v2V4kv/PgfgHqbs7PHjMNHpPw+tfSsl0tcd0wqnn6/x5FpuxZ0YLt5wtXlGd0iUnIm+vTM74tAkIQX042pVobpjLv3d8CKpgsUDWhWAgVhwElle/URMThQz/PPvcrDB48Z0wjVsoPxLRLsBu0w6UcTlOgqUTJNU5DoIdssfEyjdTauodTAbsyU0rBJiVIKw3gFMSIu4H2i1j1SCl4izqnN9nIxu6TLBFfx4g1LXvK8TTWUFb6QUzJVwTwzNtjCx30Gh6FcLH3KrFFOTMXlntE56jP1u/NCKdmM7LMoV8SCaK97d9VrBXeZT23zt5oV/+psQF11JhXMC4ZrU5ltcK+d4fYmFBfIqvMbet7sza2tqqLVjOx6jW8pxUqrD3aXmueHaV5alOsFQbV5xDgle6Gl4jF/Zrdas8u20Y2NJ9eeWmyLiFpQhyfQRM9ut0fEkrr6/SUlJXKZCMFTxtnm5CPTlE10/Cwkx5NStjlXNQ2aeI8HJBcCjlSs7XZNR7daMiLUcYNMW8RZpOJ3E83yM2+un0mtlMSygXUDdEI9cJTqyNnTrVZcXFWGaaJthGEQdr2yXHWcXQx0TWLRTDSu0sSOcbvl6f0PuXl4zB/5Qz/F4eER3/7Oh3gV3hdFSrHX99Dz+3769+H3b5LO93z45s+xPnyRH/uhK3KZGMZIVs+N48i3336T7cUlMHHrNlxdQs6tSZOqySXypAyqNE5Z5Ep0Fe8KtVj2waqFfsr0e1hmx3JVuXmyJGdPTZUf/pEvsN1+ki9/yXF+eZfoIseHx8TFTfop0ISei8sHdI1w+/ZNgoNDWfDw0X364RTcGUHNz2kdSgHncWLbctFErYGmNXeFKDhv9kDVMM+fC8GbUwj2iIy0TUfK1i1QB4JkVBMuWFxflJFVW4gW20XOlVozMQoLx9zSesoIXYwkKaS6RUJlt9+yaBummglMBMkE9RZhKdYKo8aD855nh4KUM1WC3fCwMYbTTJxhmplErmUWNv+jjFb2+JgUuOttqZJymnUxVkRm9uMzGYW9cG4uWDK/Ue0Eg3cUZzA/p9hdSWaM97VnUO1rlTpjvX1A1eiiMhc90xbPbZIzDVqpFiQizmYBOm94v2tRshlaUbW2ZqajaDU4pjisMFaAQAhW+IbRWlnx5stcdCumUpimgaOjG2QVat0izlpqAaRWasbmfkRSsfwF7z3ilGG/5eTGDWoyEeg0THPieUazhQLnlInB9GfjONgJGPs9Oq65/nbypFR8Y+3qlCaEhu7gDtou2J07VEeECcpISSO7qTehcnQEN6IuQRXy6HGuUmsiNt5W/Dqxajv84UjXmuQnZSHElZFWxkDMf5+f+Hyhfha22x6tkZPjMw66r7A/fwj9HV64dYd35S7r7iNWC+XF5xYUGfh9P7LiN37pI2I34LqJUu9y+1iR0FDFcevO89w4vsWNG5/g/Q8+IJeB+tZjhj2s1kt2ux0lmQ9m1xdWzTGjRJIWglSjxjRLHp1e0jUrtoPj5PgY5zJoYtksoW04f/IOb33tmDEV+t17DOOOLMKi6UnDB+CPCRpYL1qa0PD4wY6Dw8Bmc0bbQj8mYGlJaV7w4ihToW1XnNx8nqenjyiux4VAKSPUQCViewg79YXQWedSMl4Kp48/BA2oK0i0nsCXhOQJ7yZkTspqHbSttYTD2FJqIHgla8JLxzRW+gTteo2mES1m06tUDhYHNEFpgsw3z9lqFRpUhTKLkhG7uZZi4yiTfwWc2CEjV0ONIUboMRq1FUf9uBc4uYZXYoEyFj5TLVxGQLXgteJ09sU5pdrNy0S/c9tquaqzcHA+IVkd9OgswNW5v7SOMoB62m5l6U/7LUE8WtO8lZh/KCrqZq1anX1vasjk7yY36PyL19kbV6k5EXxjK/gglJqNIuIbfOMZ9hOq4KMzka2Pzwqk8440jfTjRM4DIURSErIqVT3NogPx5JyQ0ba0dgoDkcB+t+Pi4oKc7GRUSjEKSrF2UkXJuTcluNZnlhvn/LPsC6l2p5YZnulRs3GV69//mpPnGmoaKGVH6rfkfgtOcVLIZTBWmm9IMhJ8skF1tXi7dtES8kQeekQCbfA4NxIlEhvHuL9kKZnGw7L1uFC5eUuJIRP0Q0Kr7M++zr62XA1rXrnZ8LmX9sQwInLKODZ88NWfxeWnSBxAOoKaJc7RIsGxu7zP/mLD3fe/xNW25/TphqoNt2+0DOOW0iqTCGiL82vUN8TFErxjt7cg66IN5EOuNkoTV5yd9iyXIzEucNKQypbN9hsM/QOb0cpEjBOejpz3LN1EyspucDSLSOOPWd94nidn7zFODwmiNC4wZI+K4rzpRFfrQ8bBodVh7EgPpdKIQPDInMSWYD4cTAgeJxUlE6LDe7vpDqpAwvmMZyB4JUjFy0QICe+UrC2xWaM5kuueKRXy1LIfKkUy+4vtLPEQvDRELSw8BLnWtdqMOmvFYdBZJ8I0JrTa8kTU4cRmrqlCzmrvx1mVkIudNMuMD8A58/x+n8fHosCp2unkWh6AXC8VrsW4Nicq2aQgQQJInJXO86bFCapmOq+p2trZBcpsiI7BUctkzgS12YkT910rkRodVjVZcQ2W+nNNGlaYt6nmMnDPyOJmoUo1z/Orawac4kMkNIbVKVOijJNRaKOQkoEaYwzmrROhiS39mAghUlJit99RRVmsFlBXRteVxjyqvqNIxzDuKeWcEGAYtla4S+Hi/NIAm6VATbMkI6FqesGSDZY5TZkYO2opBOcZ+r3tqF3EOU/bCM4XXCqIBjR7lEp2GS2F/X5DzRnXBfziEO8jB+sWL4lp94SuyQxjT/Egahwv204L4jI+KOubtxmniG8KJZ0S44Amk1XkqkgVtvtM0zpa8eaBzQUfoGnA+RGc0u8SQ1JSFGJjp9mrzQez/7NBwjysxlMZQCNOdzRNy9HxLVxQbj+3trllLog0XGwr9x+PVDlEWZNcYN8Xpu0O8ZGJQuuUtr3Jw/MtRwfK4bphuT5guQgc33yBPo3sNo+o9akp/BtH9A4nDaWMjC6QPCyPbrMfJ4bNjnrxbVTO0LxDncXytTHaZrHY2zv1E8iC07OPwFuYkUrEh8Y6kZqsaIgS2w4tCY9acoJfzjITk1yJjmYrKw5tZkN+GnHSUxVKbZhSQ2xXLJslV7vAUAeIDY6EpJEgzhwRjbkQWimsFpA1Ic7TNivLaVDLjygl22IKwxag5sm27iFT0gjVOjm7KdfZhslszLeO7L8BS4bv4nF0FsfiZvsSMmvUTMkvc+pPCPNQHHMN2GnLzfiaQPCBUk3tbGtm6+VVg+FanOUkOGeWqKOjJcPYPxP02nxK7fsEW1CEIHP4zfzzKLY5BfvaRedZiG215Bp4mS0UxotlTQzDHkSI0dscDTXHRcpmQ1KhVoeLHSEscb6j64557s4nEB/o+wEfCuuTA95+6ym17NltLeSZmp7Znmq1oOeSLVQ4+gaHmvjZ2Z0w+MV8qrNTnPceZjhiwVDpQQRXHVMRJEYoI65GCmIJUs5RfUFqZbFoGXZXeCZeuH3CspsYp4Zh31O1MJZE9BaITS4MyfHywWs8ev/bnNcrulBoMAF2cUCwDfaUlVTFoAoFUlLcICxXjkUrBMmslkopgVoi01wAozQsV7Z91mBHbnHmVVYVIhmXzrl8tKMJnpqExitOGnwUFu2S1fKAq2HF07NKUUAcPjZI8MTG06sjjZG2OeFqgs3Twm4Uvrh6CXaKkxVH69e4unwP50a0ZEQ6YryBD4UsDcohh8cv0PSXLLoTTs/uMqUNbVuo2bhypU52E5UZHSGCeTUr0Uc8jnFUcg20MTDlEQK0wbzV6iwbd7VaI3T40BAJpDSx68/pOg86MYxbIDG5yKQ3bOamEYhEt2aYYBod3rVM44gXiMs13bJj2F/ShEIXHZIioolFG8j4mdfq0Hw9krKDhAvdDHZQckpoLWgdcRQIJp2qM6HF+Q7n4rPr205CH/slA88G9XWWStisu4L6ebYUnunQqs4MtqIzZtnaTjtdYULINAIzOw6ZybAOiiJaaLrGgnFzITYNfb+zbWaxjSXzvEsN9TGLU4zzpWZDNmfDvBhBHaVUvFry1HK1MCvRbCEr2Pc36q/FIM43UHNXVMyVUY2QerA+5IUXXmXbFza7gddff4OmWbDZbhFtqTVzdXpF2u3YXG7JxQzvFjbt5gWI2BDam+4vz1DGUtU2VM+oxgYRyFm/m4ehs3xFxPBTLtAEZpz5vDsOgscxbLZUzRwsOqQWfHCUXNhsr6gpsugOuXVzhZMtKTf0+2GW4FTaIFxcvIMrT0FGxgTVLfHiiaHiQ2IYEuIi7dEhKfWQkiWwZxhTIa/MNRC8EBZ2shbfULNZeVStldcK7TyH8sEBgqsRUW9UFXVUZ+MS0ZZFe5upOKbLJzx/+ybHK8eDq8p2V3DFUXHUqhTnSTnQ7xO31y2OFh+O+eKP/DEe3HvMuH+HYfrAGilfgZaSAyXZ9vPOzU9zublid/4h03hOJBO1krKB6pEGkTVtqOTSI75aTm7ToiWY+JxggIWolDKRiy3oBI9WZ7GTeUJc5vDkFm08oo0rNBWWyyVvfXvD2J9CrGSfyKNQdEnGI6El+s5QVdOIZiGGRIzQBXCSETdxciDsZZq7hcaE3lOPKyMudHYYIREb2346Z4oHi8eM8yHH5nSAbann+mAnb1u0pcmuY2Z4hv9tzKgfjwI323VQE9yauT4Q/DXnaRbYYlQBcYInPPMmGuW1PAueEVdYtZEhWdUXMfxKrWq/QK30u96EohiCSGexbwxzgvgs9i3JkOOGmymzlOM6LMMkHznZz3DtGvHB0bSCK8LUJzspNRFRR0l1zoyYnRIwa+lswL9YLHDOs2g6Lk7P2Q4JXMNHdz9iGjObzQ40MU4TpcLV9hEpj2gJiBSct/bbS6RM1ooqzqQhTinZ7C0i5gW1mZ1lXZSqBhIooERUPKHtCCKkrExXO0gjQWdniQtkOnwLMZq0YD+ZIf7myZqWPWnYkLYDu21i1Sk3bhzSNjZfjEGtHR9PuXmcaZoF958MbKeEJ3EUhU++eMj9+1sIa5bLQ9LWVOxawWmkFBgnAZ2I0RGyENtop+IQCC4SQ0NOGXwx4TWmj/ShQ0qDDx1jHY2+IgIS8H6FtA3TbmC1WtB6xS8Sd1yg85H9PjBpsCVUmUBaCyxXC+xerZe8/MItXrjzHF/99YHLi28gnONYUAQO1gcE1zCmPfcevEmzXJGnPcFlLi7esgJYCj7YsscIL0u0ZJRKlflE1axQjXNWsGnpVAdyqjineGmQ6uaCMuBl5PJsi8gKkYhUy8UVMrHxjAhFF2QJeIk0OmOg1BDhXiz3NTaTfc4CHCNOB6bNE7xUGneDUg8hesbxFOfSvNCrdp3NmlPU1A5Cg+aIF2wLn90MSDUFw/U1jRaTy8TG4Bta5jn7x/0EJ4YlB+bTmnnTqoj9IuaH93Z+QqGKCdVMImKFooplB0wl2YbHRapYDijZkoSKVmpJ1vlUU47nPNk2VSyK2TmHihmB62yh8sq8znbW4opp9cSDlOvlhaDOId6x202GZBJvd9FihdWHgKinziEtMRgMIMZgav/Z9XB59RQvFuTRT1uGs6uZM1sYp409JxaUPM7zymKAwGIzrorM2CQ3n3rLTC8uM+gw452dxGpV48dJnRc35odNNTEOw0xTdbRNIGdzT1x7hJ2L+M7NVrhKt2yY+jMuzy9N3hHF0pKCI+eBh48eG91VzdFx49iiE1WU9XHkqHq6IXJyJBwuA3lyLFcnLA5OkKIMJbM+bFg3MPaJUmz9UarHFYcPgXHMxNaACqoW1hNbA5U6vzD9FSN+jtpLaQTJNtZQj0hrb36ptE1ksThmN1j+5nqVWR04Ts+E7daTp0TKA6INJwcd+J5dnmjWh9y/d8HTx3t+67fex8nEooPFYiI0E5rOcC5xfHiL1Roenz1C08BURisIrjNXTzI3gkimaQ7o954bJy9wfnk5Uz/UYBNqiCw7uSdER8S1gCVteUmITASZmAHM5NLSF0f0HeoKpVrWiOIQ8YhmxBWaVsErvnW4qngZbDxUBUdCy97aSW+n2lKFfldw0dpPfCB403qiRvO97iy9CCn3OFHcfOrDWScharN4O9mZh9uADMZBDFGok/tvAvDSTktmz/nela8+G4SKYPmZ1zFoAuIUj2Wg4vhuaLKzU1ZR0+iUiqVN6QyhFA+anwlbnZc5D8E/04YxLyBM6JvQNLFcrOaINbtj5DxZO2NPwQqhE7RYCy0OnFZw2YTHGHEkNgsS07PNLjBfnMnyFVKZ7Tct/ZTQarqk7+oClTQpw3iF5ULa6DiElqlY0lSe81BLtqG66rWAWag5MaatCZe1ta/rZfanFmvJxZuFLNoFNE15Xm6YplmBVDNVJ7RkgsMWMwR8t6YMI5dXl9SFcvNGx9FRpEzmrU1AmiKalU0/cHDQMgwONiPLhUNy5YUbR6yWHadP95RUOT99wsHCs2iUzeXI+iCyXrSUai20qCPXyjDV2ZPsWS2X+GA3nuA7xsnj3WqGOozkCaiZ6BvauLIbpPOIrHD+ABcWcw5FQ/BCGpVxKPgW2qjkRSIvwI2etBtAE9SO5164yXba8bf+7i/zqU+8yNPNFeiCxbjiuUaJ1XF+cYXWicvTieVxRcJo15wPqLMWzkCqExRLDUv9JU4KF+f3DQQ5GdwB38yyCo9IxvuE0wl0YpoSUQqio6HFfEepLbkEM9pjpJqmiUguNhN2gpaMk0ITjBFofaefxfMznUctra4Wm40ikVJbQjhk0g2+ZMumkPm60oqoGNJ+3sTnWvAu2Oerm3l01+4kS5MTp0g1yk6peUb0K94HvBfK9w/V+ngUOGE+JV3H/ul8krsGScqMOZqLgcgsCHTwTIWPfE8gjXk78SZJ+C40076Ec8H0HbNbWWaNHdi21IlYZqMYUy3nggeGcc+1rrBab2enPrHpwjXnDSx0GZ2pD04p8+lQVVmuDrjK5+j8s3kPTip5GnHR7m4mADZisHdzm51H+jExpTxvbZXghDzkeTY4wzbLaE+vmgSkZEt5GoaJkiuK4ZJ8KOz3iVIsC0HV9FVV6qwtvL54PCEszK3g8nz6M9sbzmaSaehZNgc2HwVr+/Ez3giGcaIJRh8pY2K37zk5ammXieVyydnjJ1C8hWx75fzpyOkjz1QKKiumfuJsN3J8GDg87KglM44DcRHN6hUEpQXXgQb6fiQXO6F6H0nZ0bSdbax9JPolWjN+0SDz54hXYhRUG7zzqCRiK/T9Fau2o0QTVBNbplxZhADOkdSRqeSpkCos+ohfeqZpyy/93b9ObEeGNHF4sKbplOK33H75hOhWpCEyTZcs4oq4eIExB3b7DyFdgGQkeMwikhnHc9Q1OGlnCZWJ21MacC7MObzmWojONGVeLNnLuzC34itKXSMSbTtbs7X8qsRo0EwnCRcV6kRwJjmZ0kh0tiQTifNNTynqaRe3GcfMVB27vXCZNrSNEtxEdEoUNS1pTmgdqak+O2jInJJHNd62ir3/ZAZqlGK5JnV+f9VnM21r252DqfwOiL4i0gG/ALTzx/8Xqvq/EpFPAX8OuAl8GfhXVHUSkRb4s8CPAU+BP6Gq7//238WyDpjnbzpvuKoaneO7P4ubT3nViL2zpMTEv55SMCyS7cjQXNFqJxGwN5q6aL9Q8TNC6ZpVX2dh7/WM4DrFKtrXKtk8eOTZohSNASczOBOdmXHzzyz286qfxcAIHsh1YnPxxE6T1bR7Kfe2EdNMncCHlpKVnO0k5XTGm1Nn6YcVT3G22KgkUjbYYc4VcRVqZUqjSVk8lh0hc/KXesR1TOOOEEfEKylFtAZTx8+aOhFHiAtUAlkdmjNdEynJTNmeeRmBXZB5zPZ7yr3hp5uGcdxwcZlJk7LqlNWqYblcoDWyWsALzx/Rb3uaxgz8VcQG3FNhdaA0C2FKG7qVI0+BIRWiOtrW03g/y2VMVweWnOZ9YLXuiEFmWGnLcnlIP+5Nj1hs+4trIRygYUF0gpbebhi5Mg5XxMZwVkKhpAFxCxaLhn0ueFdoI1T14Pdom6C5xYuv/gC3bxxSNwPPP3/Iu9/8Bm6R6Q4PeXzueXr1iOPDwrAbWbUDbTOx6IT9tuHTr/8YR+s73J8GKpkmJlJNlGSz5vnORy4WvJPnOEAfbMtovz8z6js3t60I3reoCmPuUFnMk60J7wQvhTpLRGp2tLFQ8h6KdRGqdjJzEgjeWY6vT+Y0oOXo5Hn2fWWqFqQksmGxzHRhwDPZa1BtXWBRi3PmaS5ktdO3dy2In+UgaX6PfffgYmeeWaNZsc5rXkSUYhnC/9QFDhiBP6Sq2zkf9RdF5K8C/0vgP1LVPyci/0fgXwP+zPy/56r6uoj8i8D/GvgTv315MzGvWPm213GWjFTMm6YCqOG0RXUOnbDq75kH/DPL6jr/dMoT3nWm9ZlPY1ozuLmNdUYPrRScBri2P7lqL/isbdOZ9CFaoGYji8C8mMCEw2VOWKoy8+MMFnAtv1DsFOZrBc2mOfJxppVaQZb5FGnyIEPVVEzykUo2c7raFliAXGDK9iJbYbJhpAEK7ELQqpQ0kaeRGBpqCFRxaO1ZtO3M54I8FRP4imn5BE+aJsYxIb7DuQXe2Ymq1vxMs2jp5HZiTnmgDbbVizEQ3IL9ZmAYerwoy6Zh6BNMiegCTiIf3n1CnSZEKpZY5widokUYh8rSO9oIaTToQYgQo0Olkoo3XViIxKazIXU44PjWp7jqe7zfs/SOfjcypop3Ld4JOXucX7FctvjYUWohpx5BTKdVYX14B8ScBI5KszgEv0aprBtFdADxRN+y3Sub3jEm5bWXDjl7qpTs+KUvfRVdtyTxtL5ycJCRaQnqiE2hXcCNowO6RaFOWx48/CXa7kW87PFxhUoipUsEtdQscQjts9NxJSEzkCA6+a6OVAupjMQQcGq/o1S8kXjKHie2WBMtOCacTIiYRc8OaWXWDnZMU4WUZ6pOJrgFVd28mXY8eZKYivmh33jpec6fXMuSRoRoulItpNrPdkxvs+UwB+XUWcir2bqGWp/RgFK5xojpzGecDQGzesEgEfY1/6kLnNrAaTv/Z5z/X4E/BPzL89//X4F/dy5wf3z+M8B/AfzHIiL6DyeN/P8UOduFmOiVOeT5ui3VOcBlXjKIEH2LOFP+65zuJGIKfVVIRfBuMdupDHt07R2taqc8j/lebXZk6J5cLfdT3Py9Zrxm1QpaLMu0WKKXVMUHE1j6ECl1zmuVGdaJWZ1U5oKMIH7OdphzIWqdow1nnZ/3wRTixSwt5dofWmaSR2LWrc13rzyTQDCqh5tj39I0mWwkZ0QLwVuAYS22TXWi5OmSIMJYLPlLi1GQtZp0xAwhjqITuULwK1sINfOGOVe8mJDaeUe/u0CqR11l2TXcODhg7DcUtQtw30+EYIuMURLb/Q7voPMQmmven+JjoVl4KI6coGkDISolV4oq+6HQhsaIxXMxd+pxIeMbT9fdZsgV4h6tI6G7ssE7xbzCRZjSgGwHnN+i4mm6jqZdEH2w16Q9YCoCYWC57Ajdbabs8VIpkxXsVBOuXTElx6NHI4fHN3n3nXMmncglcbYpOCoxLtjkHS/dijQH8P77l9y8tcZFOwmtZcE0b2FxZ4z9FVUCTbeiakcTA7ns8CEitKg6qlaCN5tSTtlE7Jj1zfs8X092o85ZiE1HmWyuVutE0A4tvY1IpM52yELNhRgE37YYP7XO81WlFPDxgJvHr3F62tP3Z3zixdfZDZ6Hj7/F/Q+/xaqtuFCoGugWR4z9GU5GiwmorcFig5CyjUWin5dipcyaUrtOU52M2lsrTmesvU2LqcUKecqZnK9rwz9lgQMQK5FfBl4H/g/Ad4ALtSk5wEfAS/OfXwI+BFDVLCKXWBt7+g99zT8J/EmAk6PV9d/NJ5lroOU1J07QrIg3FbOf71Y1TzYDmrVaAmjVuU11CMEG+WIEX3HBZkyK9f9qs7I6QyXtJCQofl7WzsJQ+8KoGlqIXGYgpV0YIQbKLAC2ttlqY87ZsjxFacNyFifWeRx4PU9UtNT5P6/589eLb/PRasmUNFHxZDU2fWHOCS2KlrnVds4WBbWQq7k+xDlqMiIwki170kOedsSIkRjKvKiZ8VPii1liKjP8EHw0B4MPEZexnFaSMd+kwpRxdSJPBdd4Tk8vyf2a1cEh46CUvJtTtRQf7IKsM3NvQOlsUYcqDL0QlhEvhSEV9qkSGiGEaNDQJuI8BN/gwi0Why8zTYXin1K953Jzyhd/4A/x5HTL0N9lv88M00ApA857mq6hZCsCMXob7GO5nVOZw2McNLFF5QY5VVItxj0rGSh0XYuvFkjcLjxHNxYQO7pl5Hj1HG9+6z1gom0nclZKjdz9cM+dG0LJS9J4RO92DNsNnkhcOdTDkAemWvE+U5Lj9o03qLXSDw/ppz2zDttat2JUZNGJWiecS3g/0baRcXCWj6qKWfoyMmP8nSgl93iMzBGbpQ38J0MS5euRiuvwToGMk0CdQRGqLTnvcTIyjY/QseGgG4lhB2oJ9d4FpmlLrj1SC7gFTdORJvN12xzdFnmp2OJA5mve5JtmwypZUBpKnd1Mc25HLbPYWa0D+h0VuDm4+UdE5Bj4fwGf+yf5vH/M1/xZ4GcBXnnxloo4i/EzSyTeM28r50E8dqqSGWucSsbLTPTwraHM5wXsNWZJvBUHZpkEM9vLtof2cc+O/5oMXulbSvE2TwN01jVdB9bY8B2o4zMvrIiDnAgS0HlRgVhxtgF3Io9pJj/EuVhep06Zdeoawa5SKamSi81dFMuHLPMTk1oJRIRqGHQ15Hqt2ZYWzlsbXu0CuF7HN22LCviyM2SNG8hJGCdLIhfn5ri+bLQSHRBsnpULBG1QJtBCG82+lTykybI3cyn46Cklma1GC5vtJav1DaBj2o8UnYiztS7P9hrBM+UCI8RQcc7RxIZchKkYydU7R5xdA+Y8dJZShRIFPv/aZ/j2+w8YiiN2aw6PXuHmrTss2uf5ja+8SZXBRLDdIeBpmpa4dqSpIgGcj0htKdUTmoALjjJmYjcx1YG2CQzDxuZE1VqpqraU0bqnC4EXn7vJ8tYncbvK66+9wJe+9G2mvLM5nasM2eN3KxqZaJqG88ueEy+0cc3Ds8hJeI6DA2Ea7yJubfmpfY/XzDAODP0WN6v6bcupOHpK6VE1Y3zF0r32V5O1oWEejbhgCySPJdSXAQM/eCqOXKb55pjBq6HXi6dSCd46n2nI4APOw+bqIc7t6RY7rjaXeDzid+Q6zCMYQV2iaKbWHtGAk0BRB97m3DVDrSO1JlQm85dntU2/cWwQ9US/wMkRuSSqbvB+suWJt1Ndyv9gjsc//PivtEVV1QsR+Xngp4BjEQnzKe5l4N78YfeAV4CPRCQAR9iy4bd95GJJ255rZ4A5B0q5XnBWnFZchVqMhGFafU/0c+RYsVbVaaU65jeRzP9nbamdEq1FfHYBVLVZAULJE5UwLyy+u8V1LlKzbTWDgxgsD4GiTOMeEY82c9DuNdlE1YTrxU47znlUzTDvgs3YrgdmIlDyHKzC/AaqRgyxgldhFjdTjYHnxBsaHdsu1axkwXR6HlPyqxBisPOsB7zNV/LkjMYgmJe0VCS01GLQRRHDPJY8UpIjJQHXo1SmMdOujvBhYbNKKnHRkaet6ZRSbydjrfT7HU2wWUlFLWqROoeHzHq9KkxJTaJTQbQSu5YQHa6a4yF6Zw6EaDeRUi0BitDz1lu/SLM64cU7L/DyCz9G8Ad8+MH7PH38EKRnvTqgHys+rHGhkutElJZutUbIZh0rtmAJzpHzfOPpLynjRPENwS+sowiOJnijmjCLvWcU/Sefv8n2seMX/+7Pc7A84+lpzy5HWHiKFIrA8fEJP/Qjn+Hp6Za7d79FWEQ++erv5XOv/wBvv/MBm7RHeMquT3gdefTkW0aH9hY47RkAcP/f9v411rY1ze+Dfs97GWPOtfblnFNVXVXtttvVdstgENgoxI5AXCxZciwEfDBSIiQMsmSBghQkbraQgkDwIRIiBClCWDIkIIQJISjGAkXBtoQQwQZf0jjutN2Ou7q6u6rObd/WWnOO8V4ePvyfsXalVVV9c/ucPtqvtHX2XmftteeYc4z3fZ7/879kTcstDXw2UhqaNQ4eWzi6jA40JpngMzYDaYHbFOcz5SR33EVh1r2LB5qSYJcnT5/x8pOPSG4suTO3XyKbHHPcdnw+yNbIlfDVR9ezBqz1RrxKZFtuU/3H9CYZ4WyPxcB04W1t7OAZWFiW9/ng+Tf49re/CVy1mVuI8BmUkh55cd9v/WqmqF8BWmxuZ+APo8HBXwb+GJqk/nHgX4u/8ufjz/9m/P+/9Cvhbxw3imom6TmLHgBNTpV4nXD63EOHWoIACD52hmYHzN6BTK4Lw2EyyOUIe9EgQURef1uNAXMM4QSudPYUGQpOColTfB9OxxEYFlGGUzd+H5PgdGAUbs9PmH3n2ndyFZt8Dh4rN8KSyLGIDtS1C5Nw+ojEL3dyymy79KbTOntrMjTE5Yxa5FeXZyH1hNGx1Jkom7Vkx9iZ5jzsDQ3FO6UsMDVQGH0nBEzsQ/mYyRJLzbTI3LxeryxpIc/JHBs1bqFlPdHzwPtOTnKXdU/sDxfq01PgS7J/b1PhQCVMQYksjjGhFoHZb+4e1NqnLEeSkiBNOZUkUQy2toMN9n5HG4P+cCW3M9sOo72AdMezD77M6fQV8rJz/3ChZg1I7i8X1iWzlhwef5llke8YMRTKM1PyQl5uGBRSrlEpK1vBAEtVXYe/4ps/8/+C+QH4h9yer/izwZPbyqevd/ZxwsqV9bzi0/jgKydK/ffz7/z0R+RvfJWf+Imv8vFHC/evv0v3TZUwE+8bg0RZV5g5HKsHW79SUofRovqXy3TrQ9AM4o2ZGzYaSynM5EyKSLxJBhSiNenZS1k8STzjnsEKOWVevbyQ0kqyRp+fUtOGj8yYOnRKToyRhNniQbAmDgCRkWfkjhjQW6O1PfJWVQkfz+WcO5IMTwaydrpcXtP7FbehyTEWGakWZPrfWIv6deBfChwuAf+yu/8FM/vbwJ8zs/8R8DeAPxvf/2eB/62Z/SzwKfBP/Mr/hIFH22Fqiw7uWsqquA4e21JP+naWGAR0Rn+Q1Ckry3Oik7/mxHCUQYpE9mWpIh7OqOiQ4WP3EPMmpzeV8OaZbUxylU4uG+TDUNOS8h1zhlLoLqKvMqqlsaupcNfuw5kEtZhEsI65cDJXldiDrT2naBpjusbpPvExKEXVW4+UeEsJH6gl7TM2fGPfI1PWil6HTVKupDyYvtN6BzvR9wQ9ZEAU0iK1hcwEnVJPdCb7dsV9gzmVesQeubCNaSfS8py63tDaRqkLPit9jOBmJa69QxXZr/X2KIdyCxoQkVeRJdfbW+O0Jm20ubI7TAreEmvNtF0yM9xZTwr+XbLTR2Y5OR+/+Bl+9Ed/Dy9e3pPyhWfPn/L6ddfnbYPRJudlYY6N7f4TON+S1zOWZJaaSxFNiMl6PrOuzv3lihFTcuDh4QFpkSXhc++yhRjGdT5wf3nN3f1Gts77TxOpX3l1fyHnEx++fMn5O/e896VbXj58RJs7f/1v/gy//avv8c1vfsQv/uIn1GKcbm4Y85616n7e78DmIJ0zg073jueuB9hWTd6nAogkTt91D2a4PS0spgq55sq+36G3vWAskiAWp89OTTUOnMF2eU1KVZsfzpIr1+1CnzvTB3s3agFyhXkL3ilLBMf0Jj59OO5Kitlpe6Pv15A7agCYUAdTzJhZB453wUb79pIP797Ipqt3bZgj8oSnKkUxL7//+tVMUX8K+P3f5+v/LvCPfp+vX4H/wq/0c3/5SgE4HhIobVgWMqypEnbKPgckDSq5oFABIGoPt8xAadvq5xNMJAUJqdccqhQNnTQjgopHtGaYhP0kPQzdhcXhIiFOeS2pFbUpbMHRBmGSgtUEb15/GBPaRAshfLYpM076I46TUlL4ymhB75iaBmMM1+udY8dMduWPqVRT08ySUpiDakrLFDl5DKeWlT6ubGOS7ETflXqUwlcuJadPBXwoT0I4pZOxvIJJ3iXD+IkFYZNZhadYo897UoH1fKtgYC7YPMmcMTn391eWJbEY0RZbOCknhg+SSyOaa5XUrOoQmn0ww+F1uLMPOC8nILH1iXXj5nzCU2EsK8vzr3C5/5BvfeenuVmeMMlcNsXRzblhJHIqjP01Zg+sa1HPMJzine6D6RdK7hjO5e6OWtY4kCpzXGitUQpMPzEmnJan7F38rb5nTUVvT1yvjWyVu4fJ8/fPPH1/sI2FyS1j+xL3r77Gdcv8jt9z5ee/9Yr/y5//S4x6R8kPzMtVVlU3lbogGRqJy+UNd/d30piWTFkWSe9GIeWFkgdWJedjQOs7re1ct0aqBfdBsRqHyo7RkG99Yt8Bh5GNNjZu1lM0tk3YN5ltCyPUrntfTsHitZW84J7Zti2YAcLaelOo0hwdS5mlwOxTFdhB6EXP+gjalbk04cOMOa+kKkhCwe9yK/agSv1KzeHnQskAMUQMwF7ic00bR2uxvWuIoOi4IOe64wNqXpFVkt6slAIBMLkUKARmwJxYqo9TTm0UIv1OOpaVzMWQro8kisipLGx9R2CB5Fc6y43ZdbM9Rhli2JzBq5pkPwW1IyZfpunnUjP0EfiBktrdTYw4S3hvjIGCZx6DpVXJtfC7H3PQd3CrtOm0nhlDB0TOLoMBACu0afjUITL3Ox0aYVWeTBq/OQ8enEFXK5jON2qV3en7hYlUDOC4X7i8fs1wRSku5Ybz6czDJrxtTZm2b2Qgza4WyIUljtFYShw8Se3Q8+fvUepKXRfafuFy94pioimU7JRa2HvQhGplkHjYEstasG2wvWm0yySv0Lgjl8LD3R1f+9o3+OiT7zDSxvVSKamzrg2zwRxPohpMZJ+M8UDrF2yKdD684VRmLppGj85Ihbos3Jy/xPXauFkqWKWW53z80d/n9atPeHID2Eq5uWXWE9ubjecffJmv/+jv5D/9n/iP8u1PN37xO5Pn7xW+9pXGd/7+z3G3NVp/xdkyJUnMPqYzh+E2WFYdjtkg14blyVJzTBhF/k5kSbKSrPxTSbT9wnXbKbXQ0wzKkxQJFlvAnANYGOPIHqnkGvqYdAAXDbMrZdFGiRXGcNy3mOQaOUnOp8CowkxZB6LJAWXvO5iTCypoPIKgUzjzhos2PpCTSuQwWJXXYmvksN2f7o+Sth+0PjcbXEoykUyRbJ8OflPSXNwjH8Ej0MVQUIUz6e5kK8yZsBSZCxy4m3GMNcVEk4+7x9fkDabM0+lyscWnJjnT8TFo7R4/aCJjkq3Hz5cqQrw2kV3HCFcTn8y+sfdBqmtUaAq7EXdJDruQ6G1ohN4bvV3lstt3GG990VRBSXZjZgql9imXk+MGF7cFPxCMJB88i/dCNncVW85439h6o1R53Pu8KsfAjX3fQ+On4QU5UUisKXP3MOjeSFnDnOodZmGMybW/odSFWgpGYV1XxrqwbxfMH0QgNU3uSl6EJwV9Zzh88slLntzcAM66Fk7ryhg7yYxaMutp4XodlMRj6lUbTvEbjMJDu0CC5q7X1OHuzSf89ItPWE+Fp8+eMIZTyomUrjhXLF3Y+pXtlSvh3To19/BPAxGQCjYD3zKlnZE20g5j3nB7+4ylJj786BcopfEjX3kG+YaPP95Z6ntA4dkH75NL4du/8G3+2l/9N7nOD3j54tt89K1v8Xt+7+/nK7//J/jw4y/xU//Wa8a858ltxsaMCn6Q8sZaNlIaUcGpC/GZySikJycZNsxI8U4+KTYQsVybWompfrZCProjm+E4PanFWNcFn8bohW27cDpVMRlKxeyGzGS0jWRqQ1uXbdRSjJotnF4Umr6sN7zZX7GsleLGuExauwTHNRQ6TmQbH6YBwVfFYzNcRESf4jEaIpJv2xZ5GT+4ivtcbHCCGIVMupDJeAPUutoBRDuP7h6G2sFkCllO5WhzDQvrIR8SkKfD4yxJDSD7oExOmWSST6kIV06ARZQfOH20kGgpfKWkTK6Jelq5uzbcjBI+8Yc5Jy6cyYYJfzrwGpJIuykzuoi9Y4qNvm2b2m5STLyi0HRNo0bbIxAnkSgsWe2c8rXCrr13jf67MwhlADk0fIHLuPzRSj0j8f+UI0mKoO1hnM9PtJGzMJnKvhyDbdvIOVrJtjF7J1tmuXnGoHB//ya8+MFpXLeN03rDula1tO5B5gwuXJqSh2ECwUdj2+Xjt7crp7WC6aZe8wKWWU9QMtRqmvxlaOPC+XxDH4lanrD7CA+0zt5fKRryUrk5r+ztJdcHZ0md5ZQpp1eUamy70bxQ0mROtVWeqg6vfuV8ZAqUG7DCvnfee69gu/H8yft857u/SE6Opxlh2k/53b/r6+TyHi9evaaPN3z1a1/i9YuNn/vWz/Pjv7vCy+9QGDy8fsl6zrz45LvATvOdax/Us0B3Sw3znYys4LEWFkIphgkrNUUl5jkOvabuwGRJlcwpNdP6LquoJF+1PjQIwBROk02HdE7KSihrpZRC3xv7rs+ClOI+kii+T4n0p2elcdkJfGVMcR/XpTJmV2fgk9E6M2u6d/gpHrzX6R68NkFRwqhGxHhCSjO8HkNeiZLoftD6XGxwyjpopCJ3A59qrWqtslHymDEkONxCRHYTzcFCgcDU5BOHpWQRFi09gphHdeNkyaRGx+k6MabeSGkn5uPrUh6GJkNtv3Lz9ClPlkItC+vNwuu7Cz6nANJQEsjJ1/CMHE/DvtzHBEtK07LC7EoS6nNnjixZVR9yxLAKltWeetemnaRaYErhwFS5PpHTSu87jloDQzGI4qQFgXhOUkItJxbOwbpp+1QaucKzBQ+Ug1hdVhKyKtrn0Dg/SbFgOPt2wdPCaTnCezujy7trbxdKXljXW/pIFBsCh5PrGogAlSkPvhkDmqXWqEoq5MzDPukzcXteKDWrIvWhxyDBvl04rYWbm1su1zsmTi0GYzL6ldNSeP3yE+p5kpYqjGpzOldKKdycVuY8EnjVLpkt0vZOuOw7KZ2gZX70t/0ecnqP++0F2/Yx3/lu4+tf/wYff7yy90+Z06nLE77xO38Xz57/Nv7O3/0Zvvvhp7x68U1OyzPMEn//5/4dbFw5PX/K9QK/9J1f4Bd+4ZeYTZ/NGJl9a5xPHebOdt1Zypl93zifEnMkzFZIN+Ryi3fRe+bcmRyGkKLAkJKm6HaQ1cUamAzqqnuqNbEN3KQWEA4rCdUYmVx0n42hdjaT6VsTtBP6b2aHLFVQqYlzXujtTgyFrMNizs4YCiGSAibjSWwGj3Y1+du0upSMXIzFs2z+R0MuI7oOj0zfH7Q+FxvcIVbXmx6Gl1l6T+CxKtKNJ1pEcqVgiaYmmQ8QAwRCiDwfPc9wouQ1jjQsBaxM3As5LXEqtRh1u6o4S2SL8OhiPMzBfn+lXjNk+VfNEVmpluibJrNjZm6ePYX712zXBw7RMMjfqg+x+G1sqhin09qIbjraBpyejva3KJA6ZGZzKozXGYwJ+y6VhCMw12bYjk9xoswTTqH3TVNkd/K64F3YW6knJtokl6rwkjl2tv1KKQt7EyFxWVbAuF525Un0QVkyfWr4sJSVNZ+5Xq+w6EZdqmyHCobbVdPywIFKkULh5rxwud6F0qFIxzunDoykKm9rzlqlPy6HYsSksSwpkQ3pIL0Bg2xZh6ap7T6d5fKb0yQvOuimr8yemGmS8ySlqgl9wA8p6X7K5YyhqnnfZLs+WsdGwe3Ci5e/SC43FH/GsIGRefHJh1zunIdXd1RR1dmvD1we4OOXr3GffPLinsQnrLdnctlhPuBjp+bb4Ja9UZucVx52p5Ya2NVC74XdJ7ns1GNIN3fdw3lhuqIn12XVvT2ddXmiyr9vHOTyOSalVixJh70sKzmtXB8ekFOgs48W7awgmd4a5p2UBjk1almw2Zi7HGfGvEjf7V2ZJN15uN6z7xuWwk4MsKTgZjdtVnqe9aDMqBCFs81wnkaGEwEXuPM43f5+63OxwcFRrqoyKFk3ZUpCnjBjJIH3NctsEpNI3vIq+yMXIRSLKWMQ3OYcQZFwBtKkWpJSYgxZ5xzHmpnjwYECgoZygIEGM2O24FbYRmP2i1qhuFEOIz8zIyfnen9HSpllXSUSnqpUzB0oKJdVpNw2d2UgTONmKcrtnMc/b9hwbEy8y4lhjnj43ej7Hj/XsJTps6sd9sKwqP78qHrno0RNm9+iG8Sh5sRSqyyv5yCtN6xW8DYoNbMncOvY2FmXjPvK9J0+riQreCr03pj9KplYLvStY2Xy5PbMxCS2n5qAH9URvXO5b3GS6/1sTYHfsqKXC2/KkUOQZFNVqsxDkxVyXph0xnhFskZJRopWx1KVvM8g5xs8NRko+GQtK5DpVrG84rMpYLs+YZ9dbPuRyLaooiiV6/aaC6KKLKVQ6pm272CNMWX04GPy6cffwu07DO9YbpAqr97cc3lo0mMOZcPWCvNyL4xyiCh+vW6MAZdWOZ9OeHaW2lh8UNNCH4k2M6UsuE8ubdMGlhIlV7YWlKuQjqdwMB5h8pqzAmy8d1rXIbjkMzjsW2e2nadPnvHqzQt630RQb5oWiyzcuTlVSD30yJ26POV6kRMKpuyIpVQamW3r3N1dILsyPpJgm4SGa+4LPh2s0XwPbFv0Kt22k5KMbQ+YozuDjZyqqvwfsD4nG5zWsSkRTPfDteJ4WFIMGUYMGiDFidIDjH5LKfFoz3JYCpkpMMbM37oTBLk3mYYTImakx/9mUhgeOp6DzoE9JmknW/DkergdWhMvJyGvKkslyIwi6o4xmO0gUjqpFsYoMt0MWkpKyomQjbSRg+vTpzzakks/apYYE9poJKAY8pwbcmU5NIfFcuRbSDXgbpQsl5Pkom0c43aZA0yWKpyv7Y1aVhCip9exbzB2UkbXRIGSGWRO6ZbrRRpHbAqPSZM+rvTutP4gac5ocUg5pVaWpdK7BP1zGmUpLMuiA87EzK+lklOKhzEzixQQJRvDB2sJDbIPDtVISsa6rpFJ4dSS5I8WWRPyBUycb5+TlqecT0/48Ds/zwz6Si5nlnzLut6EaF30kRy2Qc5U+PCsPHn6AW/uL9QcbtQ4I82gWDiZRGvO3jr7nKGH1iE7J9ysK7Uu5FpIFrkXZhSesl2vmF1JPihFSpjuhfurYdZYauZ88yRwsg0vhYfLA+dz5fbmrNZ1qFJWmtUVmAoEd008T6cn+DRunjzFbPLxh9+GS4+zf+KeBUsMTd1VQEe3FFkPl31nzifk9ITLtsN5Y7tsrOuXaHNitTI9k7OI8rJHkjxP/0XvS8AqfXTx+jzctXsCW8A7OTvmerY0mf/+63Oywb0NnKm1Rk8aowdXsniWHa+qqyTmf07y+5o+gIbHA2GhVEgc3DrAjWz50VbpkQc3lS7vQwk9dVmY7tRa2fdGyYk9mvxlKTBFIRnjcACRmZ+cgNPjJJUkO+w5VSn13vCRwmKI0LpOPGXx4xANpo3BMGNMC2fiI4jn7cg+50wbztYajrGUJEnV6MBRkeaozGTGiWn8X1OC2UIyo+q49U5JKQY9knK5S22QMWYKInbOpNOC90bbNzpqbaR7rZRUWZbB5XrBo0VcapIn297ftjiRG5uKPqc+OrmIcApAzsFPmzHUKZRyqMwTpIrIhNqQ5ft2VcwtXURh62H9k6glEI55FbcyoI2UdHjMeU/fO/v+iuWUKOXM8DPmC8kWmJWSC+5Xtu2OFJZQOa2Qzyzrc8a84eb2KeP6WhLBZNSlyN7dlYUx+k62xtMnN7x59SCT11pUvY+d3TslqmjL0hlfd+FOKQ1G2zm/X6jryotP7zjdfI3z6ZbL3Ss+/PZ3eXr7lOu2sZTEzc1T2n6V/HoWbRB1xibdSRwWWVBLIc/BcJFoLw9vRPXITsorl8sDB5Bkpu/HLdxnzmCV635HscnkNcxnTC9s+8Ic8vkr2TgtK210De5SjoM4UUultf1xaOieGSNoU55lXOqSFp6WZ1zGDImY7Jbm3H/gzvI52eAOB9/wtLIqnWWkQOWjwkE4mpWsdCdXVF0yU5ZBtHMyKZQPaMo6HfThHMThEQBmfdw4jqnRGJOlLixlYWuNjqY3SrqXMwhxqlnw8nrfVN3lGgaIBAGzUUwpWr0dHm6utHqfuGVNwaYqsJKNwca47qQcBoDi7crK2aLKzEUmmHSRcONXyfKim9Euz9iY5/S3bbulMBnMMEQfEK6DrJxcRgNlzYz9QQOaQPLdC/vm4diCpnVuLLmK9jLf4GXKz63JRtynDEEVeiLN8EyZUgCGTBdjeDInpCKs0Wyy5MKR8pWySQaXKsNUJZfkLCVTRGXEbFCyc1q1ISakTPFxJeeFVAu5RjXdVULl5Mx5Ze+ddb3h9skNls+43XJ5cPpIktmNEdrhSWsb6/o+yVbcqtq+IlpOuTmz38eEsQs2mWMnz0al897TIhncaWVrkRnKjL3buO4brbls1a2BCedabhyGU+sNvUMtN9y/2bjeNW5O8JUPnvPq9T03Nyd6v/Dy5RtO68r1snNaFiln+qa2f8jAouYkful0CvJtG+NKSlDyZIxGn8qv9TlgJoncLXNeb7hs94HdhsdeupD8gWR3zFSZbaXmwmIjeI+yJ0sJ3JMCo5IGGNgkpcm2Nc6np2zblbYP5lx5cn6fN3cvyck43zzl/v6NrLPmZI7xWyBVC3sMm/F4CBV6MWPjQ2Q+DzuiOSHK2cPfzbpTsvCylMLVwxYwmL7HQ7I8mkXyCFKHQ4MdQTJqNXtvMU0yxrxSUpJDcGxOxWS6ONDm7CPcSLNwxJwSs4+oFgslKaGrWIbsYRpo9AE5r4y2M0ZntEZK0MZVHKgpraukLgZJ+ZJ9HMDrIJtRi8TTbYStlBNBMEcrL2PEPnSTzwmpVsxd2QvZaPsuh2LT9Krmyhw7vcgEMvlgSYVUb+gjc51dU1YS61rwfpXJqBFBz4mZijIDxq7KLSW874zu5Lw+8p7qKnG4o43+kJvlmlnO0iXXnEk10eeuDS4vioW0ybLA+aZQCywpUROMcWGpC26VPpQAP64b0xs5L6znSikntivU2rm5/YDRG+3ygrIM1tMHdM9s3VlzJTPo7tS6Mk28yTFbtNIyemhtstQTPpvg+bGxjQtbm1yvnefvf5nb5cwcd/Q3wveYhYEccoxEa4qlNHZqcZZlspbMGIXLbiSb1HyCBa4bfPxp43yaPH1izH7l9nzGcF7f3WOWKbVzWpxaE4kpYb6dsbIwCOePuQMFs0bOggrMJ2uu7O1EWU70Hgnzo0suRaNddiwncnLGTBrQIMXPsI2RCvets4+duhTq4uQhueO+b9RiIg/XSYvnuu1XenOW8pRnT74KPnj1+mOczMtPv60pvxVwQR2f++DnlDQFnf2wJR705PGgHYRAf9yAzB1lvh7Kh0DOXNiUAcMbRFKPmP0hv3I47L5loAegMbWmdulxYnP8PofFz5xR/RkMC/tkAr9KJUz7ZD1jJsLjHKKz+HRSUTsahB/JpqwoDctntGgmvzmHJNlDUEI07RoukiaHjbm7NjtU2mtSG3hGV2BNTnIJIckVd86sNsuFRxIUEguOYc5Rnc5MyifhSMPx3hmWyXYmzyZqzITuwkKbv6IwSL5hNuh9Y1JEdyk1Lq2LCOx+jJbivXeWWkg5PcZnLEtmPRl1SRTL1FQoa+G67yzLWRWe7dQ8OWXjzOCmwPlGuROtL3QbjJl1CJpwzVIk6evdWZbK+ebM1l9x3a4RsRdW2cM5nW7Y25B5wOhBmlW8Yk6KZ0yWGE2BzjUvXLZ75riSrNPGAxZpZVYGvd+zb3dq107G3f2AYlzaTq669y1n5SNMYHZqPTH6Tl3O7HtnXRN9u7CeV9Z15aOr0/o9db3h1Z3z6cuNuiy0ofthWWBZBkuQg+e4UtKJpZy434d4ZCZHnX2/j+fDgj0gorg2X+li2xjkmZkYbVypST597qswZdeBnnMjlUafet8GMyb64sIVG+RQxvQhA9mSEj2KlkTn5atv01sk2ruzb5v4sH440USi3Q9Yn5MNLrHUIih77wo9CenV7IdDrgS2R9v1mH6F8huIyevRmqVszBRTNEtqLx9bS7Wx2mcU5Seah739+Rht7CFsr2/F+aEqkBSsRFbDwBlBRp4iPQ5YT2culw0RFoXFlVpVXvdOSunR1Xf6Ed8H3U0VaIzoZ5B9ZRc1aE1W4gOV+pKi6TAoKZwbPKzbJ5g3LGkjnOhGtWjP/ajyLFFyCra7NifLWS31kE9XzqsmcUP43WKIE+fBfVoK1zcttKVQirP3SXMNViwhQqqLX1hSggjcKTmprTRVyadzZT0JkE45UVOmZmPMjXXRwMGYlAy3TzJPbqsMMy1z9xAmimOqCiwr6/qUy3YlpYZx4vnzL/Hi5YfUtoflk5P6hbq8J4x3TGwOVdSWsDTZpwSbcwjkTnEQTm8hG3LOp/egD2bfaPMBM3j58hXr6Ub33NxZiiuEJ2eWvNNjqijidcNozBbBzW5cr5Gje8qcauG0JK69UYpxf7mj5DPP33tGG5O7qwMnytr50pPEzXmn1imO5MyUWqmnZyzpCTXDKWeufcM8aDWWAteykIkNUi4yCMXIeaGsUE8rb15fpCEdGmjllKh1Ye+dNi/cLs5a5LN4e1N5fXcJ/zbRtoSTHvEAgZn3nRbRlJeHRusT8xNOYR+dMaVhbVPTXLmVfM4ruDlEFygZxsJbe5Vpb3Ez97BH0gbmxmO1lqSYJ5keErVn0pR6YNP5kICF5s2xoB+EeWA6ZkLf402VYjO0HDkNMUxA0XvMkKXkwWDHvephn3IN2S6bJkJy9BKx+AjXCMLssbH6FI2lz8lMOUinjuei9nRIyzendLBLidQhMyYZb502RzDRD85SgPRW8CTFhzNk8ZwG02FORbPh0kgQDPVMUbVpsCRZ3ox96CApVSlN5lzbJs5duPNi4apyeNfVSeqZstzQ5/XxtE0+qSURujZqbG7rUtV2poExWOuNRNoJUpIV03BYKpRkUcVNLpednE9gC8tSyXngTb5iEopfSNbIJv7X/d2b8IG7cFoqrU9S2kL3K3F4SVe268BTIZkoNrlkTQ+90fsb9r5RykIpKzVVZruglKrGjAhH2cVPgfM26F3RfKTO+UbVZLom+nDqSTZWYwza7syheD7PTrfJUjJWOiMN7i+Dva9sfXB/XdjHoHlhKYP3nja+/J5sq/bWSfU5Pk/0XhlUbP0atXxAyQO/fJfZXzP8jTJWZ7xGNCjpw8Xw9aPqT9zd3WHxDOU0WcpgqZPhInfn3DnXQg6B/HbdGK3Rx6T1Sc4JkuPJ2Ntk24MHOydtiOBjDglZRF3bpo7FZlgveWzGaPD0A9bnYoNzh/s3d9w+WVnPmqDsW1fLNQ9TIxfuNjX5yzk9bg6Hg4bSroPYCo+qgXJgTrwlA1vw7PRG6v97kvbVY7ihpUqx1MrlciWJzUEeSpaSy0mDpOsY01HqlgXnSLhgi9a0b7sGDEH+ZsamFppD8xgQhlpF+RHKTCCrYumtaUNXEs+jE7INFyZkGqz0vgtbTNDbhcNWxmfCfASBWJUKRH5sdlrbgz8lqo4l+bRlEp5KGA4I/zytK1tzasrcvbmwLJowu5WY4IrKMb1rgmtGXVf26zV8/XSdJSXW08K6hEQvG7lkWT2lTEozZGLShCbTXVFyZkmVlFRB3T5BEqFDssSA3FkDJ6s5gQ1KHvH5dW5v4eGiA7bUSfEaksAR6hNZcGOF2ZsMGU3BQc6g9x6Uhozxijl3fG68//yWly/vOC1FbsY1M72xrGcu1026TW+M3smuziD50f4m6o34biMyR0br3N911qVQyg19VPatQRr0Xsipsq4ypbypkH2XdjM952G7oe2ZkhZyvuX87Gs8ffoMZmL2ncvdAz4URwgXcdsMeruqe3GFNI+h6hQf1LU8mmDW3DgtDqnwcJnMNtjKpLfB/XWnkeQsPCepuPKFWyM3yGXBUiG5k/KkoeLF+6TmEi4/nbVWqJneQhowK9veIwT9+6/PxQZnBjc3Z21afT7aFvmhTdVOJpCdaBGVqYelQpRsMR1NcqjFsaWSiowAmaFdNFkNpUMyle2RfmARWCNkTd8DRJaCHnSlf2uTwEylfS3h6BCaviQKSMr6+5oGeZzaCbqqwdkjaX5IwTCanHrB1BZabO5TmZtSYyT27mx7Zx4eYGgym0n4kNJjRDuuHlUTOgt8Z+w72QdWKgntqArB1qYlUXUhUaguegdJzhRQKGbiIsXdsy4LwwpLX6HdM5OMD3obpFzDC+4KFHJZON/c8CbeTwuNoSVZBHguMajO4q8lXV9zwBNLSlgRJrqUTClq5k/nhclOHw+spcqAYa2c6ok5LpxOqkZqSaJO0LnucuM4rRcmjcLKHG9I+YbhaLhUVykrbDK602ahGOyt673KFZ+R75mOmMKNZM7r1/es6y373rSRT93DDw93j/fZkmGbk1o7hqg9Y4Zdlu+cyhIPycC8kw3uX2/gG+fbM+89y+zNKMnprWNpcr4543bDRy9fcb65ZW8r2A3uD9yed3I9a6ObhftXb/B9I6cLKTVG19CN4LmZAG0FLRUnFSd7D1nXCG7qwOdGzYU39ztQKTnxsF959uQJLW1sDw2bqoyHSw8+PNHapLpTk3DPPibZxfvMSbm65HDv8alcX5dZw4TAjD/nU1QHrBYerldO60rbLfJQJbfSRvdWgA/a/EqJ7+HQsu3yZiOkW5FhcFR2RNbq0RKWIrNCieAJLC4YmIHlyQNNVaVmWwly+FiNwTQLEbw+oOGGciS1GdocAtR90HcNICRQnqrwpt6BObr+jivfYF1ODE9MT+zbhZoSebnh7iqiKLYIWK4nbbQY3qQdNEvUXPCkh2OEsiGlomq3wmxymUhF7rhjNnHaXO6wKfIlUhhnylIpcT6fGV022bk6Lz7+Nl/7+jd4eT8433zA3Ca9b+IxsWvC7GD1JArIvtEub6gJkaeruIWeIVeZKJSaIodBA4GBx/AhM7qqaSkx2uNnfb1eyUVDEv3bRt+v7F1uxoWVai4ftGl4SvTRSFbY912W+WTW5RYrmYeH7XEI4W5crpsmd2lR9e+VMTo5yTlaLcDAxx73ZWamzD7l/OLWGQRVBgvybDg4+5B/miHb9Cw8rk9JxYY3Su3U7KzZOa+FnM7CGy+T3gtbH9ycbymuUJiPX2a27X3Sm0TOxvl04csfrNTS2PfXzP1T7vY3svWyl9zewLbvmM9In7S3QzOyptpuNAYlZUpYHg0fGJ0nNws2d57cniAl+rhivrDvk+tlD92onqeJy4rfpVLZdyctMslgHtrzgZuLEzoMECnbnchjCIchxiOF7Putz8UGJ094o64nrttGLgsgXOzwPvvezQ10kaCWVZ2PvW1PrWBJGYslA6H1DJdyUgrqSbzhzEnKC6FajSGCPN408i6AWNVPnj7hcr1K00gOEbs2yxFYsOO06fQ+oe0Y8sLPZcE9ErHmwJFsbLQZtBFCTJ/Yr+LujcOmqWS23ni9XWRO6UauSzDyazDrnVwr3VVppchcIDbpiTSjTibXHFcb/vulyIYgV5JXFEKTRT9p2+OGRzgf52Vh+sZprazVePLklvu7FmnpsLeNbq/xeYHpnE4nuhmZDmOjVKMuazi/Jmo1liIKRClGLUXkY5OgX/m3k5xgLYlJp9ZKYrD3wbIoF8HClUETYMOqkYp88q5XZ1nP+pBmZV0WihVO6wkrG8lXkslOKFnltN6An+izUNKJPjYmnRnZBqIobPjURF5V8BFeTjQCUj4Iew0OexygZjOs2LVR6xZPGDW0x/Z4D6yL4gH7nFw8MfuJfRT2ueC20FpnmLHkM9fN+OC9r7CeJ9fLa9wfuFwfuL9/Rs8n1vVC7/8ubYpgi3faZddhXiaLG9erDueaErMgOok5oPc1587sdyxlspzAZ6N7Y87JUiqWdrJXPnrxmubpcZDQw6qfwM/7CJYCgmPGBPcgeiODUqsRjfhYzBxdmJ790T/nQwYIIbxPliU0fzkz+iCnooiw2MAOOdeYXXZEJuqFmb5vjk4uJcijk3a9QpUzB/Ptz9H0Vf+ypFKEEkATTN2J+q8iysSmvn99r3G3XgSyKjJmRA5O08fQxnj0hjPXNG8MtTK3t7e437FdL9JHllP4jXXKAvv1QmubHtakh948UU0GRsONEfkRc7pIqyY7dvdE8YWS18BPehwGqiSyO07WBJMJuagtDJ5cQk4dmA4Hm52Csyzi7e1zSHCfjNaFhT65PfMf+D2/n7/z0z/NL3zzJV/90o/w8tWnFHtg7E45reTTDfscbHsjsUIfPD2feXMnBUlCOFzNmVpSZEWIyCvLrEymU/KklCMvFtlV5YWlFm5uNYWcrbNaZilGSVHBJ0h1hVRClaDNpSAd47Is1FRofcPbjqWFlB0rkzQLicx8uDBakFONx+mde9XmlWJwlZIw2LFTq3hh++iYlXiAU8iSTNe4hJwwiTrTdmG7OUuGlD2Reib7EsqPSmfFyy1zrLQ58NKgFK69kbnh049fgl05nxJf//rX+KVvf8jd/WT50kZZp0KEgri+9Z1SlmgPd7zv0FtIHmWAOsfOGBs5FboPHuaFpexUs0iTA3cNlu7v3kA1Uo9QZle3QwwGZ3g7xn6OoXhMC8L+Ic/yKZefnBKeEzBEPxE3i2T2ljP5A9avJnTmBPw/UEpJAf4Vd//vm9m/CPwngVfxrf9ld/+bph3onwf+KPAQX//rP+zf8OmkGZva6I+ctRSTv5yd9bQyJ4+kPmcwIwtUCUMtwqKzevUmwHKmTqKq2vJOzhOl2yvpSN5Y+tlyDxFMNuUnjoeWtC5nnj655eWrF3LamK4HIMnGB9eDNHr4/5Oxmeld1kgHIdH7EeDc8dnZUZzg3iY+Mr03rtcL+KSUQrJGTarirle5pvbIdphTLbXPneQTygIUEkq2mj4hhRIEUVrMlNXqrFip2jgsy5aKt1NNtb0zNK5yjBiRc1FzZU5Yaua1Od/6+Z/lF3/+Q8ykanj56hP62FhyYi831JsnIi1fLxQX1jmT83C9sJ5qxMBJSUIJ5cWYirnLqnjXYpxKBh/klMipss9JWTJLkY62XTaePa1YlXIkpY4tRmuqClKqGAvTFX68pFMYmMocaN92Hi73wtK8KTd0bJyW9/DU6EUW5rnc8HDZ2Xvwt2IynVNhYGEBD8mULzCGJta5yKuvjyY4xIzuRttkyT58su9OthsWL6wHBFMSl5Eo+QazSU2N4ok3eyPlSnFnupF9UtMAlKVQ10rfL1zuX5PyPZbhvDxl7FugP5NUMueS6LNR84nRE+RKWu5YszGHKlqzgaUqM1Gf4rKNzl7VTW07PGwi6rpl5nXntGZSgeKJkgvbJtfsaaE59snMjYbcQZKnGNKpOiOJIjX82BSVHOam96W77NTLbzD4eQP+kLvfmVkF/p9m9n+L//ffdvd/5Zd9/z8O/GT8+gMo7f4P/LB/YLpzve48eXLL4ba71Mo+DwPMJC1n0CowI9sp6AwaYZulx6GAuyorH3qTfDZVSsmkezzovS6X0j34NIZIphpyHJWedIX7fmXfd2aTPConbcxMCxfgjSMZXBSJHJZOaldak2bWEcdKAc2o7B+T0WU/o8BI0QyYVzIiEW9bo/XCHDEzmU2OvePtxHd0bWgj5GvKhhU+kwpQRGEpa1iz+yT7ICfH6I/BNlKVgJHoWxBzEeEz50SpOmhaayzrypyNmpEgf8pr73p3UQQg4KOpgkY+b1CU4BWyt5wLOYtrJrskHVp5SQwGtzdnzkuiWGdrTVNFKqelslQx9Jk6vHIR2B6iCZLBzUkk0WybwOw0IA3cL2FhdgYrtObMqdQptbmqzvv+IJ5fLuRcZNnlncPl+XHkTfAssWDa54BQTJvHMHBnrSuOMyeUVLm77HhaSemk+z+faSPhvlBKZc0nTmshJ9jba5YCW+u89+yWy6XTbNCRv11ycTVzAb821pLYtjecl8n5VPApPGx08Rh9vhE80Qqti88pkvLgoWVKueHSphRGFMwVeNMdsk9OJHI6sfeNLbIu12rUaqzZ8GWh+8KYk4frFSaMOHDaNCyfGWOjWBg62IjhXcYoUl0gydGcom8dhUeyCUdF+APWryZ0xoG7+GONXz+YOgz/OeB/E3/v/21m75nZ19392z/kH6EuZy7XzvV6ISWD9IS6iIyqB1kBziP83kTWnY9M60OZIMT/UEAYPvTguMseXITXSSZJcjPBktw9ctIGEGMP5uwaFKTEHHJATSkuPUjBmlRm5hiMuQXxsL81H3RNNHH5y8k5IbC+JEdWWYMXRutsm0J7ay2c1kHb7tlHp48Tc2hQYiHhOhQM6RDV54LlRZXTfsHHYVwZWlNLpHQGgxxmlTmhAGuk7RSZekQbZ6STZD85O7NtlGURX3E2gelzIZWKU7huV/Zx5Xa95dmzp1zuB0doDRnWteK9x2aRVKGZJuAlSy52WjO1SHaaiwY/57VwKoneNmqtzAEln2BeqBlyUshJLYnelF4v63u1fCXJgFFQhnIASIU2nO7Ofr1CWtibPofZ7ZFHSJXttyZ3qzDUiFdMKFntOBjcnRSHQDLHx67Kxw5sqei1IcmdDGScp09u6MDwQllWvYahARNZlBXo7H1jzp0+M2OsTBfPrKxhBzYah6wxxXR5WeF0TtyczkAXhmpx3jCYBveXndHFBVRCmKa4M4mSMak6UIcyUJalUpcblpxYZuPN9YFuRLcAh6lC74Nsq0xQh6qv1gbMzKCSy3NSvuW0TNrlBT7vZGXlcnqGrNcYxHIf/sgxPWAm3T6/wSFDRAb+NeB3A/+Cu/8VM/uvAf9jM/tngL8I/Cl334DfBnzre/76L8TXvv3LfuafBP4kwAfvPWFvEs3Ombi5vWEO53670ncJ2Z88OePeWU9LgLbO5a6JwzZEDJ4xmDiqrzktqBrivY1IfM9WISVGVHU+FXPW20VtYSphPqlJV99FnLWwhbYEbYqBzXSUlek4VdmZvYOpmlI25WHLfLTXHioGneJ9FoY725x41lT09vkN28ML+t7oOH0QioZMtsQMrGfOIOlK/R5W1pJwlSxbG/pQRVOFa+T8lhtZSsFnUkBJ2MMnVFUNy/TmnKqGLAVnPZ3o+yZwfJjSzmvCueHpeiI9fAJsLNkY2RnA+XRm7w0faq9L0eezlEzK8OTmhh6xTrfnzLpIgH8cbqeaWUphtBSWV4VcK8V3TouTCnh/q1XWxPzfSx+Y7pra+Uo2EZUZG5OL0rSaBk3DNS221Gm9MefOzSlT88Icsude1hOnZZUKxAYlL7QmTEgAvNP2CxYJa3M4liVnKqlqQ076zMeY2JAHoqfMGLKNZwnHnCIi9pjKAMlWSJy5ub3FbaVtr2G+wOdOTgpYsiSMz0cDT4zm+FpxDEbDveFzMDKMVrhu/sj9dJzRGpaURqaupuFTsYpt7sy9sWapZV5fJxcR1yjJ5ECC0YcGdZYTe29ct6syVNrAUyXXM1/68o+z1C9zvXvBpw/XEPXHRu16Xsbc4/mCMTzkkeKtiuifYPwGib6uJ/P3mdl7wP/ZzP6DwJ8GvgMswJ8B/rvA//BX8/PiZ/6Z+Hv8jt/2Iz76FJlvXTGHbdvJJZPrqpBYiOmaUQwag1xgdtkejynXDp8z5COah/pwcjEoaqtKzcGGVkRfbzM2p0lCGBrZMQLED9cDM5ijaVJHUVrhSBETOMioYujtAJ4t2j35iPVdPmaqKCp7e2DMyTZkb96n6B2pZpbgm+17we1MMsfGIcAWkdg8+HvJHoN2J42x76QRoT0549ZJ1Y43PTBHAY3SzCbq6eZRd2s2meZ0h5vzM27Old4u9D5Euty3uAm1may3T4SbhGTkybMvgTe2+xesJdGTWqtizjSo56JNwLL86rLD7CyLNqTzOVGznC7sUK2MK54Ly2rMWXGv1DxZowokqwqv1WTOOJ05g++WE50Cu5NtYaYTyRbGNBKDtejfuzbos5LKeyx24mH/LmYTPLPvE1vVfqWU2VvH0sr5XBhT1BWYCj6OiX3O4QKdwEO/mszCYl6hSGM2al1Yag4LIWdgkFc5u2A4SxyEQfZm4bQ+4xu/8+vc78a3vnli2IZPOfB4UlB5652cJlu/MseVWrvu/SQu3ug7PhutdcwqY15jClygngOn7KzFYBQGje5XPXO+cX/p9E3VZJtQIw/V2yacjUJxh6Ish+06mXOJYGrH/MrLD7/Fabnw6SffgfQKT5fHTQx2jjQ8ZR3LWQeT401vUrXknIJS9hvY4L5nU3ppZn8Z+CPu/j+JL29m9r8G/lvx518Efvv3/LUfi6/9sJ/7PaX8ZNtVrdycTuzbxtPbM4nJ6ektCbheNpaystRCwxUsE8TgnOKkMo2T5W/WadtUXR5SLuYQRytwvlKLiIjTFU0Wppl99CAbi7cGCoAxT/RdH9ZgQta/38chxhbzvs/BGEayGtVTptSFfbtjRNK9wj8aOWWWusKcvPjkJWN2SrJoOYzUQymhWQiGxMnCfac22RilHyaCJZcgGWdyrmTThM+Jza1WtXNGeKVJTG0G77//lNEnL1+8JCd59e1tI9dMykkVDhZJR6oouyvop6QVz00Gk6NxXlRZlpRZV+N0OnG9DlK+JeXKmK9Yl0ZJwvsObEXViOPslJoYHc7nMzMst0H264kUXcDCwd0uuUA6073IWcUKc57pZOzwDyQxu+OjUsvX+PKXfzf0wS/80mtSnhyOzXvbWZez7pWioVE/4IxknJaqtrNkWmvyHtRxxNwu1FooWXO6HiEppZ7JWdzDpF2aXG4gLWFO6Vy3QWuJNraIMiy0MbnfEts+8RFk1yTViBlYGBOYb5zKwhJUIcJbsURg0bZfmMyg44DZrhyLXTYUqSzUFHb507jf7hWu5M62T0avpLJi3hm7s1+UzzCTbOxvTwvbdWPfJq1n+lRrPuaG9zv27YH71x/Rxw55A0Sd8pAFaV+QDVrK+pp5xj2HZO5ImvsN0ETM7CtAi83tDPxh4J89cLWYmv7ngb8Vf+XPA/91M/tzaLjw6ofib+hQqYuxrpXrdZMH2DSWWjRAYLKcCq3vVFso+Rwbk7AJ9/4oolfpWsBT0DdEnAV7FJOrjD/E9iAOUqU3YSbunW3faWHvbLGJJJPn/+hiYqdcNINIiet+JRWjh+NsrqK5KLD2sGPWv7vennlzp9cyRxMOFlwg2TJ3bdq5UNZM268CmPtg+ECwayY74Stn4RyrTZaDUpMSEITocHlU8LJaolwq89DKmrCkPhq1iPP2ySffJZmzLAauKmNdCpjap1QK05EQe27h0R+ZtlYoy5nFigYmvpFT4lwXSu6Mcc/5fMuP//jv4bLDx5/8HQp3LLZAVoydz6FhQ5qULC7kkjPrkvB6YnYXh8xmVG2ytRZJ1bF8IuVn1HQrkwFvuEfWg1W1ZaykLO+2WgrXh5e8fvUxNU+sLCiSUX6EMzhtMko4pHKT080NOd+Q0pnl5gPMEnf3d+SceP36NWZnUUAsRzhQ43y+AS9AItWF4StmC6XePlbX7pnT2VlW5+FamL3T+85lu+Ob3/pFlmz4eI3bA6JQKMti7FfMTa4wPoIAfeCd0Ppk78a0kybaftaYZG4UHyRztdxlYYzJtm0Mv5BLTI3txMPDRmtGWZPoNfsV94XRF0jOTSo8XF0a0wn7TngcguUb2v6A+Y7Pq8w1EpGRqkM2WeIwCRmuDJLDoUfsqQP2mT9MivqrquC+DvxLdoyW4F92979gZn8pNj8D/ibwX43v/78iisjPIprIf+VX+geOVqkHjiLCq4JN2rZze3sO9rhD12kxNIDjeg03T49nmCNRUV5ryRIprxoIcHxAprzRHhsYMJqQ/+6yPx+u8JM5/DH9aoxOb1uQf6f84CKNPWVlSVpykTP729Mn5h4sS+bm5synL15w3QbbdQ9AVuBpLhWfG0vNtJapddVmMmVM6Z7E5cvipHmXY0ifok7gobdNRl1kxJhTDirNceqprK/5ezA8YnLK4dwCOdfHDTeZps3LKq7cddvINkiL6C31tIrM3AJ38gR1pZQT7lf27V6VQ4FSMz4GtZwhJ37xF/+2JplppyyQ805dUlSVkuSU0PuOPslVEXb1dJKXGppUCjl05sxKeV+fYfl9PAnAt9koedcheNhM9VPgfINSNrbrN3m4+xbTwt+NE2VZHpURw8GHxPOHsX1Olb7teBbZ9f5hCwmguGE3Nzc8PByse6NkWE5ZU/Th0uOmzHq64eb8Ac/e+xK9Jx7uI70sizQ9x2sGr8lccbuHca/3I10ZBr1t7H0SKittkkPk4TEm1PTotdhnxtOqzX40pmmYN8fksrVHCOP+olBl3zu51IjgPPHw0GlDBg6tXainSllPDBbW+oy+vcb7lVeXN5TAng1ntCsT5a+6W4ShJ5QcUR8nl9P1PdmMQyQyhtRKTOIeTVE0JNx/A1pUd/8p4Pd/n6//oR/w/Q78U7/Sz/3lK+VKrZm6nLherjx/9kTSJgtNpgN7wyeQSmwaRi2LxLZB/htThEmBZgJ3LQvMNsv4MSF1yWLkPpViMiMjv+Eqz0updN/BJ23f2PdNU9SUwuI8C2QvmdkSzEPPOjhi+nrX6VSXU7RlG9u10ZqoKdmMXOQunJKCqu/vL5RcOZ9ueH33ht6RH1o+UfKkubSQIMlZjaAWSzFlzarW1uWkDTykZcIALfhlsUkzYzI5lYykyQtwYEYpnFjCvSEmkykJ96w5B6O8kOxEsmNKKj7evjd6Skwr1KwHvHvFiWu3xrLIvy4tGXIDb9jMlLoGzODUvHJel7C21j0jlZvAdzxRy4lkhWV5Tkpf5ubJT3B/3YHX5Pkxbb+LHFrDu1xGmCG+t4LZAykrgMZtFUA/dOiG3UOYKnRVIpRo9YOo6k5ixKCnk2qltwdV166Nd29d0q05tIlj7PvkfF6py8q6LKyrczrn0AYPZvuA6/3GYFLKpLV7LHWWUlgW5+5haEKfiVact4qeiBC8bo0yLFQWau2zVSg65MZwcrrF/RKGk5M+5d9nwLY5WI3ovqR8VG/kkvC5KyazZG7PT/jui4+wcYdVuYeM0QKjlbAeO3KHM8kqo6PPkIPipQ3riJXUhNqiiyqBtwfVa3rACN9/fS6UDO6y8nYGbd+xOdiDLlJqoaxyixg7cQLA7P7IJJcCgUeVA0HLsAN7CB0maQn3jwFp4tsDw5yST8wWgmhQ5ZTOEQgie5aBcAUi2syzMafoAPoA376VI/SnPt/miy5rZtt2Hh6uSpoK8uMYna98+ct88unHjG5KU5oG3njz5gV9TE43z3h28yXevPwO23jD7AKKCXA1P1604TlpepoVElJSkYtFMkgV88SyFAzZUJeSNUnNOj+XqFhkeBgW1SU9HiBMZ11P8gCLqfUMcXheCiRVodk7xSqpVjAFBpVIUUo14WlyXitLPpPcmL5D6hzqkWMgE6NRnEnrW2wezux74KSqNoRxyrNs+Arc8vTpl+jjBQ9vvsUcL/DUSHmwt0m2RUFFqYSBqFHKc9qEtSxkE5Y2Z1ge1RuSFfq4ikNnClwmK/U9uThwOQ08DY2DXK+/JDmzDG/kPMAXDZTyqpOmD57cntmuV3xq8NV23b+n08r968ZoG2Pu8lAziyl8Z9/kuIEtDDpmZ5JByTJ67fsFn2/ISb53NifTBlYaR2iP7NEd742tPdC2B4nuTfK9MRqLiTzdgoBdiuOzsKzPuH/9IcagXV5zV16wnM607Z5kHmT8RRNUV8WWSUFOj6EgB83jCJqCTHmLrXlw8Ei0pvswW9zvThhdfP/1udjg1FUpxGKOyXldaa0JmC2Fdt1IyXRKTJFBR4ukrOPDHuHYEfZEFsA57mR0AszexINKak8P7pJcRiJ/EcMGeBc2IC6c5E5zGJaXeMn+OL1Mh/4R2QLNOR7pKykVDON6uYITwbXHEEDylQ8//PQRvDVLlCJvuDEGz9/7Mqk+5ytf/QaXbePyRi15TgmliOvUBsNKnJIRTGMONYG5s+SEFQG3dVHQr0Trbw+GXErQajpLLmSTkN3TQX5Gr91Q1ToHy7owZpemkU7NlVJXuaU05Q2c11UcwTG16eVEm5t4eqWQ6glmlhllVEK4JGgpdZqpLa+5xM2dNW00C+6iU5Imk1Zu8FQwH3z0Cz/Ntr1izg8pi0KxoXJzc4OR2dsVPOkBjIyNdZHmcl43Rr/KWcPy4/UnT7gnpkEqwWS20C1beuwG9NCqSjQKve9kGsmU+qX7Uzrada28efMKmye+8+1fYI7B+88+4PX9PS8/ndKkpgspZWY39t6xvlHMKecTtSykkXj6/ANuzl8GqyzLCZ/Oqxef8N1f+ntc+ptoow2zybouiloc2mTGaPi4sLcHfCrQxT3RhsDn65iUBDfnFUuZJ0++xItPX/P65UuwCFcak9dvHphDmHGioG5paBCUFN6c7O3BAfLD26/ySsxJrfKQz42GhxB0EMP7EEsihhBvcfTvvz4XG5ykGeIvnZaFGeW7M9n3jZwyMyUsV30QXacRwOHC27sAVDvYE1FZkNVeHeGx+AjcRbpBI4WYP+N2YDnCTBT5l8ALo01yXZhT7ZtxGHHGJM1FsJzhZuvjyPhUfsIeIuQD81LVB2DhZzU5ou4GDnPh5uYpy3rL8w++zC/90s9zuT5AMkoqjCA9puSYB2YVWJulBFnXZYG1ffUrH3C6qXz40QvG3MAbt7dPMTPu3zyQsug3ve0crk4K9MgBqgeR1YghhiL5hk9KWcjZ2LcHkg+95QkGYpvnkklduKExwAdLrtESwz6v1CWT0ll0g+mMrhAUS5JCiVhtJLS5OOnR2cPZlUxmeq217sztY/29dA92Rx+Z5XSj3ICRKLWQ7QSmqe1SM3vb8Hk49+4y3fQwc2DEYSZjgoHcb/WZVQUIOeR0g9nKkm/I5Yb1rDT6y8Mdbb/Dx5Xpe9juX1mS0dqg5oyPe6Y/sPcrL9+8Yt+3xym+U1iKDsW8Kqyo+KRtV9Z1xcc9tCvX0cj5GcWfU8uZH3n/q7x68Qmv7pryQ5NhkSzvZB7uL1iSdVWiMoe4j/MIJKqVrTUKhTEqvTtPn52ZTXy8kgf72OgTkcHnhZQvJAajObIu1GBL+KDQyxFDISeKESQjnPkIZZei5Bg0zDFhhITLD6vyFM/a51xs79Pl+Nl3lqoHoZTMtsm88bJtlKVSFuFC5hrRCzsIU0mynirBkiHT0kN5OM3qH1PaevISE0+wFNY7STZN29AHPmdUaFl5AqqwZpTMQdI88KCpaa1uFJ0wZsbeG31OltOZfd8ppXK97BwBx3pARvxeYdbJFj744Mf54L0f46NPfoGPP/o2+/09zAfFyZEwN9a8gA9K1oSqdQXQLHVhJoeasaKq4sXL19RX4DOTU6XUyr7tcd164McclJSYTNpsnM5ncb9GIruA9lQye2ux0ckIU8Bo5vZ8i6m2oo1OqUamUgpsMzGm2qGUpHDwqXjFtRwWR44jCkYuJWLrjsNgyuYo3qeEM72JvE0W298cm52xv8ZcnnBiOj8RGL0XdQl5srWd6R3YtGEDY2zM1rEis/jDVFUpbUGdOMjSKZPTgqTaBXOB5DmfcS/c3nwJZxWQngrvPX/O3d2roC1t3D28BB6Y3ihM6BfAaEP27X1/E8HiXVBNXkU+nyFdsqDd5MTD3UvOGebudDpmDzy8/pBleQYU1pr57T/2DZ48fZ+9DV59+gntesdgkNcFZme2B0a/0JrT5yqctXRac957/gH396/o+4ZZ5ZNPP+T5s8KzZ1/D+Sofvfgue3+J+RVmx5js+5XZ1D6OwNtycmUxZN2Tc5YYrgUZH9lHYR5SROU7yPn6oLl4GMaKMqPMk9+AVOsfxnJ37t7cczotTAp7a3z68iXrWqh5YTSUwTmuKA1Bk7qtKTsymaLjQCe+ouIUW4cVJgGSQ2A44QqbtBElD2fZIVWC/KUsMLIR4dEjEqACdCcA4raj0JYRY2y12halpKeEeeL6sD3y6eYkJFEejg0pqjgB5imtGMb9wwve3L2k9QtjvygRbDrLmuimVPKUwqc3ZUhOrVlTuplorT3qcSeJrU8monIUy9iYwQHUcKe1Jjug2THPzCEKhmzeA9TFKTVjJiJo4iCPBpdqhilitG42Jn3fOZLJD/xIB42Cfxka0Kc0sahsx9Rpj0OtTzBOEC4oliat3+PjQUOPUG3McG/xPhg2cE6c85Ow34aZjFKfqPqe+rd7GG9KUqdYwDwzNpImkWxgPaDAHA/eQs4nkp053bxPG5WcF/btApx59uQ9Hu4eGOOBZ19+j5IzI0xPU8os52dwfQj/N90/zIv0rZbIppS1OfYgQy/0ucssAYXn6HlXq282uDjctwl0UpFwP/WNU31OroW71w+8/OReucM+ef7+Vzg/fcqciTcvX/LRd38eby+5vXnO+flX+Pg738THa8zgzYs3jzSNvl/xmtj2xukmU+qJm9N7zL7z7OkzXn36Ee3aaTPctbN0uaMbvu/47PQk7h9ewbucrOORysF/HGOKvuMDSKEYErdU1ae84PygKPyA9bnY4KYbn356z9OnUJdBykbKi9rOaOPaddDzIGXxemYfpLTgU4aEzsEDi00mgF/cJPpOFoqFHD9S3mEzJjWPo9qsh9gj40H24S7PuOCMtW3n5slTen9r5Ad6KAlzzKVWtv7W/bcUedthLh2g6d/pXRuFI9JmrSslGZfLR3z68YUBLMvKwx7TJZcw3z0pTBXhUNlOJLvnK1868yNff5+f/+YncqhFSe6Y4Tk27rpQaqZdLlJJGGLSExZJpvAQRRZqwqkwmqSsgpxlP22H20vCMtrk04xIueVxA09LwbrD6DH8KaqWTVY4KezdRfPoZEuUEOIzF3wU3DLmyp1Vl2ykXDG/gDW106VKuZJzyLQWsPC2q5WZEhPhRWluMbRQMLE+v11T5iJzzuFXye0Mvd9R1dd85nT6gN4q+8Mgrc+p63NSaYy9x/t7pfU3zFGo5UlMHQcPD6+xbVBy5itf/gZjTD599V0u998l2yQxGYdMMLUYRmRabzpkogMRHSkJV7RJRwEt2BpZFM6zp0/4ypd+FDjhTN68ec3Lly9YauH1qwdaTzx5svLe8/fYHjof3b+kX3bcXjO2K3ij1kofgzFgOZ/FE8XY9isfffhzXK5XfHROp8Sbl4PRJy0GFLJhTdwst6TbE29efUIbD/hQoVBSVgU+wvAThUzpMM2hRyVoJhMs2nUPxxlAI7bP+QYny25x1Pq1sZ4Wtn3gA0oJXg5gKYNLceCSYMom6bAtdm1zosckYs6uPn3OCCoWZHn0rG/DpsM9JIjAxL/pkTIkAoCoHw8PD5BL2FqrAhxjMOPNLmWVSqL3wBHscRP0eEETieVFT4F1XehdmthlKfi8x/0OTBt9zjCLeEv4FMM8i/aBDwodt50bO5H2O84Ven8L6qdMuGwUVRRdp+YhtD+MGc3E1D8m03C4JUe1V0IsjjHDn0ubpCnMZyr+bc5JqSuYOIE4JKukvKhtjM1NnaWzVADRayxnQcxWSPmsgyw50BhjV+WalZ2b8plkqnBKkjA95/pI5B5dVdrYO2V5AhiZgmWj2Ebv9xhNr2/OINjulJQoduLQqgwXQJ/ygiXRPaY7dck8fX4WZSRnHvbGq5dvwDaGX7ncX5j7mcvljv1yB3aP4cxZudzfcXPzhOSZRGHOFgdv5Hy4KFJSRoSNOdIwyw1F960sxKSJHVM+dH2/cvHML13/Lr0Jrtn7het25Xf/xE9SyxNad+Z+gTJZTjqQGa8Y8w6zHbMqu69cyfnE3bXjSRy1te7AhZQ7VqacqFuiD7C6YFODwNkHvd1DkmTL3fExsKJ8Cx9duFokm3lg4CkLg5tz6JlEXUIfKmwseJ8Eh/QHrc/FBufuLOHmW0oi7WKay4gv4vNap4+hvMdd9Au3ET5mssgpYex45HumLPa3hg0ZCywypYy50/v+9kXkjDNJLm990VGUUzDm1AkqpS/rTYjHCfqEJU3LXJtZLgqzSWkhB+fJHbXMqILxlDSJ7CHpajPIuEn4xbwCM9rSHoHVR+6rHEXSEWoTJGds5dWbztY22lCMG6nE6L0r1MOdfd+1vYfma/ogm7JK/dhkLAVOqGmVRPlqs4iKzkd/dLBlyHeuhQW7MJWGTYJtnvGZ6d7woUHGHPbIBcQTjqbVTmWaZHcH10ze/130BFOgDp6Y+2Baj83+SEmzOMj0OlIWUTnlgk/knRcyPEJuZRh5IlzOnZmdwkKlkMoZSuJh20imQdEcjVKkmLl79Tqqr4Xb85n7y4X7hzssD6DxcPmE1q5Me0Gfd7DJYPTVmysvXjh97hhXqR2S+GCzeUx4ReKVi62TbCEl6GNntCHL89lRu9YZQzxIy8bLh5dw/1Kfj3dGGFv+7M/+FD4LPow0FywXHvYLrV3JtfHQL+SyMFt8Rkneh/uckh2S2GmU1MElrG+767M2oywyJidrGCaVmLC1kO+Tmazrid5VSMQMIQjhyv3t/aoN33UPpZR10PvBjYsp6g+eMXxeNji4bEorlyuvrHhqzbQemNBx86EkpYlCKeZQlTTJNNROid6Q8C5XAhExNUVdyhKebZpcenSnIzhraTjmJVjfDuHM67M/MtQNtcDHMzRQWT3D9PK6yfn15slzrltnBH6SYlI6CVG+ayI6p4JeeAyrAQZimqPKBZ/qlnJR6MocpKwHdXqi+07KhYcd9qlYtlwLU8Z1wiBz+MEpsRhllUbote9y6kgx2fLAB0mxSfewXS/0KS+0hCa4Rjg/DI+bzx7NS0vKcYNKDud+OL7MoIN0mLppzeIUt04pK2teaKPT9mtggYNtXJETrd47C0K3woAOQmmoNIYwyrqcIZ3itelBn+3C9AdkRa9EM6Jdd5MNdvcLa73BR2JZVtYqC6OBFDJzDoa/YdpG556lPOH+zT2X9kZuHDiX6x0+jd4vTK6iCYWxgoVpneiagjDMNNyoNcufLojG3ZsOuTAeVTNLUKLEwRthvY9l9sslJIqFkiY+N31Pn7R5oS6Fac7IV3ofNNtgnezNSGnVBhg66Dkamai0LLPmM8Um1+unIrLbLTk9JZXKdX9gXF+Ddels0xrv6yTZAsOYXUL6h8umDdAyE7k4n5+cebh/hcqNEUbckjgqblPdzxH76eOHzhg+HxscuBQC3lnqioJDRETEImUeac96a2oaZg+JFIAY9zZl8cyxwQWoy5DQPueF/aBB4PHGafgaMj1hH9H/mklgP2OcekxwlaoNxCkCAXrOt+RjsnO5vqY1mWA60oHajJM5+Hy1irBpKWIIvbKs2oS/9MF7vHr9huu+6XV2TXBtiO5S1orZEmL9nbLofBxoY08Y5o0U6eHKjZhIhpTE6sdY11McFOJyicvXmCZvMoWoyFJ8to5ZOJtkUSQEr3lUkdIRZoSFaUrrYTYqsD+RYVgYJIxHJxPQQCZjVORcu7cLo131fRZyspiOz+KhQdaHYVbC7TUB4fQyRdhNXZiNeyczMFPauplstoQJlsh1EAakbISFMeDy8KCK201Tv0c4w/DcgQvbLov9RFeVGa2jjE6jAxiqptwm7rJeKuvCvuv196CqjOmczu+T8on7+xekqWyP5HKE9nC7kavNzkFob/vOmLvycHPl/nIVed7H45Bkjk4fCGcdLaRuE7zILWVXpKMPAflz7vH+a0K/X6/cX6/0eSUvmWfPn/DVr/4kS3nKt3/p23znOz/DsiDaVapAtNw2dNCVisfmlfDQqDqDxpv7HY9BU84CPR9xdSem4sQBFrb1B5fk+6zPxQZnBsm6SKNNRL4+Arwm8J/jv8emFJw2iXNNbUdyJbKXwpyy75EJoOmNdgsnVtnSHAaFmrCKUjDxaIUKvffANw5hv0Fo+zx4cIKvpHboPuld8W8pANQ+drlsxAQomaIR2xx66HsjpSnLZhNILm6S8/rlK03RmDQflHUVJhKbfesayR/eWGOAZSObMKg5dgH+JYxD0eu8WVa2/TBtVJQbrhG9oXbkye0T7i9KWepdyeWBhMT1qCI+yJoiLsuAEDxSzUTRkSZd4vHDqFDBPxZSqaAJHARlq+zXyZuXL1nOiYg8CR2icjxzMfGiCJ+8w2rdh6ySetfEsjzDZ6P3azi/elTf8uxTVlq0PCgoyIJrBc52tIfmFD9H1eByXzbDKeI+pkEtiRmB2jZdm9HccZcrTB8Nt45o3NocL5e74GHasS0/bjrX/cKPfu0bbJcLfd4zh/DEZOI5+hQRu111L7inRwIsnNQVmHJuZa9FfI7ipLUxkc+bDvHRpM6ZPhi2M208bn4+Z7T9XWRdtIEuuWCjs9+/YXm6MudgmmCG1prssPT0it4BoWkVBTqHWWgyow1ZXVk8WG8pXkl5Jlb1ETN4FKP/CutzssEZp/XEdt1JKbNtmm4d5FyfHpjWIb59a86XUgk8rZNykAc9Kjk0rjxcCKRVV4RfWJpqw4yHcMTDSeZxczscSnzq73o80OoNojWL1zKPSaAbs0t7mHNldA1K5E4uJUNdgt9DYm+BrQUfS6dXUW5q3zGblOA8HelbKRXdnOYBtldZf5s2CU8eJ19jegUf7O2K5cy+xcN+pD/5DFeR2PBH4v6+Y6lQ0gH06gAZx2Zg+nuGtIqH8aa2wSObNaym4mspLTiZZCMOJzmmgKoJdw9r7MHkSl66dMF50RRzZtrY1VbPTq0r59OJ3luQRo0+5W7yGOzdL/TemTQOSVA/tIwTeHyYVEkTEqCcjOUkl+Jpk2RZou+ohGwK4iiLMm7xKjPIVBTZiHILmI3ZNzwDj23e2/dQ2RMTHzPu7RiGWYd5x7d/6Wfk+OxxH+qJ0cCoSIlSq7I/QNCC+2Df7hnXSwQSCcfsQ1jqujzj2c37vLm/4+76UQxZBr1NmMI7Rx7sozOmDFtxY4zOshCuw9DdebhO+vVTLq83Uv0W99cGdmFO0V30uTRt6t51b6KKPeUKLocVpccpdD2H+mZGIaKPrTBHjgJnxBOogzFUyd93fS42ODDZqaRKj5H9ASJi4q4lP5jPceZGhTBaZ5ooAgMPCZMHXpSF6U2nFFUbo89H/pFyUS2mgoezhsemIfB+qPMUmBntaEoW9jKqwrLnxynPCInLcrphPd3y4uWneDz25nIxaRFSUsIcsRY5f/QpjKuWE+6Jsk68JK6XNwp/vl7JyxlzVTGqWpTUlXIYVpZErsYeU9BiVWC9uwY4SW04JgNBbagK2E1JjrlOTJeR3AwzBsqYzanC+J52Plu067Hxm1yBh8cm5g6I3OpdLU8PA1HcOJ1usCROYM7hGjIk1NEG7SQmuSx0d5l4+oLTyGnldHrCw/1r9rbTRo94Pr2O0XbcHzBEGHVCZxwBJk5ktppaPQ8OgmgznfnwhlwVsKMpZ1j5hMW9B6HV3Uk1kVxgfx9b4L+OsZMYMDUcSQZpatKfs9LclROqN35aWGjZJJNxf6PnO6IztdFN0ZfGrvtmu+CjMV3uzPJRJkjkhbZPclnJButp5Xf82O/ifPMBr9+84d/+25+S0iJcu1/p7FEZi1DOJOIC4xmYCm2aZkxTdmuns7d76txlPBq4bZxuAhymWvDZhVMfEZ69b5JEHgogVzSBM+SbZ1IPlbzo+RtDbatF8JKPz/8UFYLXcrSiE5j+qHc8TtXDu21vnblrM1uXVZhc12BiTFcK1HTyBIIs2vuDdItMSYiSSetoGeWowkSboQXgbZbooz/qRsdUxTijvQ2CFMfEIeIFcCaXyxvu7t6AGefTiow0e3zoiYOOUkqVcWJKSoy34Ov1TpuakKUSpf8YWLuEjEXYhDGRdulo794K4x0UNONdm0MVGdUIl2M8JlD6OapkY4PqXe9NzrK3gXBBlm2TmSq+MTTY8dDxptDD6vOQ4qD3IztD1XXJMnPMWdbwmBQgJTa4UuRMa6hlH0NUibos5LrAvNHPGplPP7lyeXjAcrRAJjeP6DlxFkg35HoCawrmnntUa+IWGlHhjxnefJAKmoYfpb9Vcl55DKTxI+wnBa8Opo0gQ3pMnPVviG+p+3jGxphTDaL0oLdrQB3Rc3nXpqJsQTyUmf1o910wivfOZOC+i3KRknDraK/N1CZbDIC6G2cyD3dvmDt885s/JwiiidgtZ48uwnWqAd5r8BdvJ3sX/p3LQk6HEkGKGnUqnVJDQuWJnBQ2lAIC8RhIMaFFFezeSGjIl00dljZVj+hNDRPdZJnmXZ5Qg3ivP+8Y3HEhB8bWW5f5bmA+wyfzaCmJN9szfTj94SEqE/Xo3yud0qlxtKk8srF10+lEdhNelI7xGQKbsahCoq2ZYwa9BGUcmKq1GdykFOaSEhZrw57IteK67ZzWVcYBfeAGVmq414qw28Pzre/iPyV3rE88Geenz7lsV/bLfdwAW4DrR36A3rc5OiWt9F0Aei7KA92H5Fj7TOS8wGxvqzOXrM2RBZAsm6QXVAuaVImEsabG9cK9EoqOcxeWWOtJk9Ghtk2hvjLntLTgro1sBPs8J2UjrKfK7E2hMX1nb5tCbfKJWldNBxNhXiDe175dY3BxpZSo2j2pOg9VSEonan0Pi6Cd6aJ3MBvelXVgFqe/a4CEh3moB5/SCpYqpdxquogO4jFmtEnyx5hd8Y9SeEyO8CI7RnyPz6A2ube6kE4o3vEDXknHvRjV0mxMk9ddtiVaZuVbtCZdsUVV7pFDOnsnpRHGkNr4zRP3d69Jw3l4+Dm2JjJvotP3hnnR9HJCb4D5o+a5D3VWlnSAEQL9Wiv79ULOciap2Rh9Y5I4XLZ7v0oBYvb4K5ccG3WjWAo9+nFQqq0erctQohhj5jjYXd2KBb7rigz4QetzssFpQ9ImF3bfluXyAdFGQO+y99FIHEqc1DphOq09ckg5UrWWJcfPf+stBeAxjXGXfi896lj9sexVfiiSfSFFhCPpUgnKxYwcgxGn3JjH5uCR2G3kUtm2TSX1nKQqbM6C7c0c9G2XTtPFtZvxQJs7GRN9Zc6gSzigbNbpMUQ46B6mCjRbIg2XvTour7UWLWPKwmj9COgJikSS84MdPLHZ8NHikPCoQDLk/OgH5rHZSnIWN910DsfcMXUCp7QyEe/MUlGbPyTHalcXBjd1CNX6PsV18pOMtm/Ijt7Zrw+0cQ1OVRbONw5HZ43Esy1MT6Ryo/d87Iy9McYFd0XiqZs2+vBHDLE+Oh+vwq2mRPSWSuBmggH6Y6h3DpJzYEPeRa9wYUOOqppkx2BD15NTxafe6z4aAyW5TxuPZN6S5AI92sBmWJpzJLkZmQVCVjcH+AgPuiz7pxF66pRhFGjjiqVCu155ub9mzE7Kk2oFMxURo+/UlMRltCQitjflmMYgx2cnuZE9NrzZcXa6S3kw9x4k7YGlTh9y4zk2NpBhQZ+RBhec1FJEuyFkc30meid4rjC8BR3JpXoxx8cMnPdz3qLOCff3WzDpNWFLsTn0vnMQMSwlheoOfUXAfAm9m6qyw0kkhZNtH/ORJ2TH32EyHlOIRPGwFBY3ZkGMnXHoJrH6XdhGKYXpLn6e0CxZLbsrPzTDtku7qJJIpFQlAXVyKjy5uaUN6HPS246PHUaXlMp7UDUkl+pt4/Wrl/L4KpnuxPhdY/wULeTcNko+MCsNLEYA1m4mlxDmI5m3T1n/WE4kiJxXZSbgRioL7XoFgsITVYWsuyfewwLSU/CvABuaMHtUxYDZkFPHPkXdSWoF+5ByonvHU7SivZFzJXkoVkJdUqp4eNfrp/i8R4HgxhiRjdDUVh+Ij89ErScNBcYDs7UQ9nc8dZrGzXJgQaD3MRH1lJlUclpDGhV8NYQXjS66g3SyQWg9hlOBO44Rdu4z+rrw2VYKl8T6Y25xeoskbYCyQJMgkOY07/RxmBzckuuJ68MdaTyw9Z02O31m6Wqj8vF5R8knUlEWiM/JSibNq4LOq1rdisFspJwYLgK0LYl919RyukGXNNBdm7/Z1PBqdlW7RASmJ9KQzRHpOGQnbldSTnpm5ojO6XvvsyG6F/1RHeMzRfavyPY5iwuq6EtZ5VvK8vIzJ3lmRsbF91ufiw3O56S3QW+NulQ8HnYB3TGXi4pM4K7Y1Lp7+iNIbUceQEoChg0OS3IsMKnpGAMfesgdWMvK9DhlZuBqwY+d4RiacwaPqi6AadDPZwo3uL09UW6e8dHHb7heBPKnuPGPKsDMeXP3SoL6XIEpmkZy2uhkZrioFvKysO26+ad7DDTssR3Wa1JiuhAxgg6gqkQ7TFA2sEclxRyqhClJuB66qQh4sKTMaB0j4ZbpPsiuHM8xwxh0xKGDYdRoN0TdOaqdOfReN7swPKvldhDHTLSJgJnkGoELQKZpkteNw+G1j4uGKOlQV0xyOgTYNTaQ4x3XK+v79e37G1QHn+3xnhCGqc0054VkCs+BTO9SA5RSmWOw7RdtkjGFSbZwEJqFw6k1nT6i8hmaco8m+6uk4ccYBxanSaB8+yJDIqbo5iMOpgxWHz//pSykOWDstP2BToa0QJL56JgNBuzzAVtuycsz4W+XO2oWLWNycBJhpkp3o/VJm4k5K31o6JZsiFI1PezCQyWUlJPBFE2lt8FwkW8FGx6kXsOKuJfmTVQbjYmx6ZjvCnM3PXfNURHhQSfCH+WSI57lo5V725Jq4vsIM3yf9bnY4ACww55mhB9a5FvGRHMeGEC0fHOIj1OL6BMSks9HaZXcOiIPdfC4KUk3L1sgSYNC8Pv401WZzDHQODsHa10biKZA8e2ualFgttQO1QY/+iPPefn6wutX9+LxTASSxlBiTGddzuQi7WLvG6kUQOJ7VaHO5XL5HhKrKYPhUAbEaFwTQL1Phweexe/X04Ijg0QnpliuDU2cwKmYxBTidIM2Btt2DbBfLhke8EEpbzFOUHt/TLpzVLo+NhzIdSW508euaLqUY3qkhLGhuYra+tEgV1E3GKpIDSz47AcPzjCSycpnssXfVViOtltNXlNKtLZLp4x2bovXqftAYqFkVf8tCylV4AhwViWfhrHP7ZHL5rNLPUNVMtX3TN1Fx1AlOOZQPgVdwxgL/Gjq/oYjoHmq2p+x4YWwP+UcfDRVNBo3Xrjb7kn9yn59w0D23wfe693ZewfPrMuJJzdf4+bp1/jk4w8ZPpi0OMTVOjvOcGMfMGZhYKRaFSRtiev1os7HqkKOgg1vc1cWhsbvwmUP/eyYYQIrk1SfgzkmOQmL1XQceMQOxUOcBnjBkfNxC55oCU2r8HNVv/jb5xSCMva5n6LagZ0d+JcDlUczSdODpHBjwi5bSgVHhoE5K7Ve09bJaMLKHgmlSEqln5ND7CHg/FGTGq2mHuIZrPVF7VyIgDE4nIPFkYtJoiVevXrg1YtXPHlyy83plnuPzaMuXK5yeDimsa9evVAF4T2cIYzWOukYns1QCySnZMX77d7Zu4wdU1LLnNLxoQdAHbrTibNt91g4a1jKEaYi7t1E5OjD+ZdQb2iIIIub1nTK5qTNzwYCeOP6D28yRehFoPDY1faMcEgesmAy2wPwLtKOphwypCB0hmmCWWFZb5gckY2uBxO5nfShCZxlDSvMCvsut12ZLog576jizKkoA5S3YLS7YbVKOkTCJ2FuqlbJxLgNnqIspjwqM1ln17DPGoH7IYDfNSia4639vTbLSeq7poHu4QYTaVAuXzs9Bzk2/RkVcWDGbgL12x2tbXoPUtEUelMYz+wOaMLfeufli5c83J1I+ZanT24pNbP3xrZduFxe4OkS1buR06KKeSpwSdPaTusa3ByDppQs8jA0Ae9jPgbImA3W4qK3pJAKxpBltiEowmdELRLvj0G07FhmuIJ9hhulLDBdlKIi4ryGCqrUpcs9+Jef9w0u1jHuHVNl7vEeHC642nyUqWBMUkkiOE6HOhljB0sc6eYHMP2Yam9q66YTtjrEDXa4iRzW3Bqzp2DNu8O0g/+kdg8IrGLSHfmeDU0dX7zZsM0ZSdZJxSU9mVOgqFgwJqwpaAA5gPeMfOklbdEkatsbow9KXVlvb7lcL3qmDJpPSiqBYcRQhLcHQg97I8ZksGtgUCttDNLoFJM1uSZ4apscou1T5dz6hqg4OVqyo6redfObNiG9fk1tvXcSPXC4EPG7wrtTzjEYcgi7Ik/Cn0T16eGKEdyvOfC5477hcb1HZqYdmGHOj5PydNiXp/L4s45D8sDqZlAg3AMEJ7AhC7MEk8Hl8VkLryscUX86kqCF87De9UYe8iv0FC0mgA9ZZbFHIpoHXAG4ke1ELk+wtDLnld7vweSUMwmSMTr0+pwRWuPsW9MBXhaGN7D8OGkuq/Glr/4II53Z98bpdGKdk9P1ysMv7XJaTi0OR5mYzjFgVnKuIlR7p5pw1HEQ3F0HS+sTsZc1jKgFltxY8oCwQNLALgjyHsO5mo7eA6I7GmPSu7FP8CRYwNDQw3Bt3iXMl3J0ZNODNubwQ1pU+2Eckn9Yy8zeAD/zWb+O36T1ZeDjz/pF/CasL+p1wRf32r6o1wXw4+7+lV/+xc9LBfcz7v6PfNYv4jdjmdn/94t4bV/U64Iv7rV9Ua/rh60fPF99t96td+vd+i2+3m1w79a79W59YdfnZYP7M5/1C/hNXF/Ua/uiXhd8ca/ti3pdP3B9LoYM79a79W69W78Z6/NSwb1b79a79W79A1+f+QZnZn/EzH7GzH7WzP7UZ/16fq3LzP5XZvahmf2t7/naB2b2b5jZ343/vh9fNzP7n8e1/pSZ/Uc+u1f+w5eZ/XYz+8tm9rfN7N82s386vv5b+trM7GRmf9XM/q24rv9BfP0bZvZX4vX/H8xsia+v8eefjf//Oz/TC/hVLDPLZvY3zOwvxJ+/MNf2a12f6QZnsqn4F4B/HPi9wD9pZr/3s3xNv471LwJ/5Jd97U8Bf9HdfxL4i/Fn0HX+ZPz6k8D/4h/Sa/z1rA78N9399wJ/EPin4rP5rX5tG/CH3P0/DPw+4I+Y2R8E/lngn3P33w28AP5EfP+fAF7E1/+5+L7P+/qngZ/+nj9/ka7t17YOxv9n8Qv4x4B//Xv+/KeBP/1ZvqZf53X8TuBvfc+ffwb4evz+64jnB/C/BP7J7/d9n/dfwL8G/OEv0rUBN8BfB/4AIsCW+PrjfQn868A/Fr8v8X32Wb/2H3JNP4YOnj8E/AUkxfhCXNuv59dn3aL+NuBb3/PnX4iv/VZfX3X3b8fvvwN8NX7/W/J6o3X5/cBf4QtwbdHC/U3gQ+DfAP4e8NLllw3/3tf+eF3x/18BX/qH+oJ/bet/Bvx3eBtU8CW+ONf2a16f9Qb3hV+u4/G37KjazJ4A/yfgv+Hur7/3//1WvTZ3H+7++1C1848C/77P9hX9g1lm9p8BPnT3v/ZZv5bPy/qsN7hfBH779/z5x+Jrv9XXd83s6wDx3w/j67+lrtfMKtrc/nfu/q/Gl78Q1wbg7i+Bv4zatvfM7JAufu9rf7yu+P/PgU/+4b7SX/X6jwH/WTP7OeDPoTb1n+eLcW2/rvVZb3D/H+AnY8qzAP8E8Oc/49f0D2L9eeCPx+//OMKvjq//l2Li+AeBV9/T7n2ulslS5c8CP+3u/9Pv+V+/pa/NzL5iZu/F788IV/xptNH9sfi2X35dx/X+MeAvReX6uVvu/qfd/cfc/XeiZ+kvuft/kS/Atf2612cNAgJ/FPg7CAf5733Wr+fX8fr/98C3gYbwjT+BcIy/CPxd4P8OfBDfa2hq/PeA/x/wj3zWr/+HXNd/HLWfPwX8zfj1R3+rXxvwHwL+RlzX3wL+mfj6TwB/FfhZ4P8IrPH1U/z5Z+P//8RnfQ2/yuv8TwF/4Yt4bb+WX++UDO/Wu/VufWHXZ92ivlvv1rv1bv2mrXcb3Lv1br1bX9j1boN7t96td+sLu95tcO/Wu/VufWHXuw3u3Xq33q0v7Hq3wb1b79a79YVd7za4d+vdere+sOvdBvduvVvv1hd2/f8BCMRjmBIHSpoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 读取词典和验证集\n",
    "with open('../data/flickr8k/vocab.json', 'r') as f:\n",
    "    vocab = json.load(f)\n",
    "vocab_idx2word = {idx:word for word,idx in vocab.items()}\n",
    "with open('../data/flickr8k/val_data.json', 'r') as f:\n",
    "    data = json.load(f)\n",
    "\n",
    "# 展示第12张图片，其对应的文本描述序号是60到64\n",
    "content_img = Image.open(data['IMAGES'][12])\n",
    "plt.imshow(content_img)\n",
    "for i in range(5):\n",
    "    print(' '.join([vocab_idx2word[word_idx] for word_idx in data['CAPTIONS'][12*5+i]]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 定义数据集类\n",
    "\n",
    "在准备好的数据集的基础上，我们需要进一步定义PyTorch Dataset类，以使用PyTorch DataLoader类按批次产生数据。PyTorch中仅预先定义了图像、文本和语音的单模态任务中常见的数据集类。因此，我们需要定义自己的数据集类。\n",
    "\n",
    "在PyTorch中定义数据集类非常简单，仅需要继承torch.utils.data.Dataset类，并实现\\_\\_getitem\\_\\_和\\_\\_len\\_\\_两个函数即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from argparse import Namespace \n",
    "import numpy as np\n",
    "import os\n",
    "import json\n",
    "from PIL import Image\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils.rnn import pack_padded_sequence\n",
    "from torch.utils.data import Dataset\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "class ImageTextDataset(Dataset):\n",
    "    \"\"\"\n",
    "    PyTorch数据类，用于PyTorch DataLoader来按批次产生数据\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, dataset_path, vocab_path, split, captions_per_image=5, max_len=30, transform=None):\n",
    "        \"\"\"\n",
    "        参数：\n",
    "            dataset_path：json格式数据文件路径\n",
    "            vocab_path：json格式词典文件路径\n",
    "            split：train、val、test\n",
    "            captions_per_image：每张图片对应的文本描述数\n",
    "            max_len：文本描述包含的最大单词数\n",
    "            transform: 图像预处理方法\n",
    "        \"\"\"\n",
    "        self.split = split\n",
    "        assert self.split in {'train', 'val', 'test'}\n",
    "        self.cpi = captions_per_image\n",
    "        self.max_len = max_len\n",
    "\n",
    "        # 载入数据集\n",
    "        with open(dataset_path, 'r') as f:\n",
    "            self.data = json.load(f)\n",
    "        # 载入词典\n",
    "        with open(vocab_path, 'r') as f:\n",
    "            self.vocab = json.load(f)\n",
    "\n",
    "        # PyTorch图像预处理流程\n",
    "        self.transform = transform\n",
    "\n",
    "        # Total number of datapoints\n",
    "        self.dataset_size = len(self.data['CAPTIONS'])\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        # 第i个文本描述对应第(i // captions_per_image)张图片\n",
    "        img = Image.open(self.data['IMAGES'][i // self.cpi]).convert('RGB')\n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img)\n",
    "\n",
    "        caplen = len(self.data['CAPTIONS'][i])\n",
    "        caption = torch.LongTensor(self.data['CAPTIONS'][i]+ [self.vocab['<pad>']] * (self.max_len + 2 - caplen))\n",
    "        \n",
    "        return img, caption, caplen\n",
    "        \n",
    "\n",
    "    def __len__(self):\n",
    "        return self.dataset_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 批量读取数据\n",
    "\n",
    "利用刚才构造的数据集类，借助DataLoader类构建能够按批次产生训练、验证和测试数据的对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mktrainval(data_dir, vocab_path, batch_size, workers=4):\n",
    "    train_tx = transforms.Compose([\n",
    "        transforms.Resize(256),\n",
    "        transforms.RandomCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "    val_tx = transforms.Compose([\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "    \n",
    "    train_set = ImageTextDataset(os.path.join(data_dir, 'train_data.json'), \n",
    "                                 vocab_path, 'train',  transform=train_tx)\n",
    "    valid_set = ImageTextDataset(os.path.join(data_dir, 'val_data.json'), \n",
    "                                 vocab_path, 'val', transform=val_tx)\n",
    "    test_set = ImageTextDataset(os.path.join(data_dir, 'test_data.json'), \n",
    "                                 vocab_path, 'test', transform=val_tx)\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        train_set, batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\n",
    "\n",
    "    valid_loader = torch.utils.data.DataLoader(\n",
    "        valid_set, batch_size=batch_size, shuffle=False, num_workers=workers, pin_memory=True, drop_last=False)\n",
    "    \n",
    "    test_loader = torch.utils.data.DataLoader(\n",
    "        test_set, batch_size=batch_size, shuffle=False, num_workers=workers, pin_memory=True, drop_last=False)\n",
    "\n",
    "    return train_loader, valid_loader, test_loader    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 定义模型\n",
    "\n",
    "ARCTIC模型是一个典型的基于注意力的编解码模型，其编码器为图像网格表示提取器，解码器为循环神经网络。解码器在每生成一个词时，都利用注意力机制考虑当前生成的词和图像中的哪些网格更相关。\n",
    "\n",
    "![ARCTIC的模型结构示意图](img/mt-cnn-attn.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 图像编码器\n",
    "\n",
    "ARCTIC原始模型使用在ImageNet数据集上预训练过的分类模型VGG19作为图像编码器，VGG19最后一个卷积层作为网格表示提取层。而我们这里使用ResNet-101作为图像编码器，并将其最后一个非全连接层作为网格表示提取层。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.models import ResNet101_Weights\n",
    "class ImageEncoder(nn.Module):\n",
    "    def __init__(self, finetuned=True):\n",
    "        super(ImageEncoder, self).__init__()\n",
    "        model = torchvision.models.resnet101(weights=ResNet101_Weights.DEFAULT)\n",
    "        # ResNet-101网格表示提取器\n",
    "        self.grid_rep_extractor = nn.Sequential(*(list(model.children())[:-2]))\n",
    "        for param in self.grid_rep_extractor.parameters():\n",
    "            param.requires_grad = finetuned\n",
    "        \n",
    "    def forward(self, images):\n",
    "        out = self.grid_rep_extractor(images) \n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 文本解码器\n",
    "\n",
    "ARCTIC原始模型使用结合注意力的LSTM作为文本解码器，我们这里使用结合注意力的GRU作为文本解码器，注意力评分函数采用的是加性注意力。下面给出加性注意力和解码器的具体实现。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "加性注意力评分函数的具体形式为 $W_2^T{\\rm tanh}(W_1 [\\mathbf{q}_i; \\mathbf{k}_j])$ 。\n",
    "\n",
    "- 首先将权重 $W_1$ 依照查询q和键k的维度，相应地拆成两组权重，分别将单个查询和一组键映射到到注意力函数隐藏层表示空间；\n",
    "- 然后将二者相加得到一组维度为attn_dim的表示，并在经过非线性变换后，使用形状为(attn_dim, 1) 的权重 $W_2$ 将其映射为一组数值；\n",
    "- 再通过softmax函数获取单个查询和所有键的关联程度，即归一化的相关性分数；\n",
    "- 最后以相关性得分为权重，对值进行加权求和，计算输出特征。这里的值和键是同一组向量表示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AdditiveAttention(nn.Module):\n",
    "    def  __init__(self, query_dim, key_dim, attn_dim):\n",
    "        \"\"\"\n",
    "        参数：\n",
    "            query_dim: 查询Q的维度\n",
    "            key_dim: 键K的维度\n",
    "            attn_dim: 注意力函数隐藏层表示的维度\n",
    "        \"\"\"\n",
    "        super(AdditiveAttention, self).__init__()\n",
    "        self.attn_w_1_q = nn.Linear(query_dim, attn_dim)\n",
    "        self.attn_w_1_k = nn.Linear(key_dim, attn_dim)\n",
    "        self.attn_w_2 = nn.Linear(attn_dim, 1)\n",
    "        self.tanh = nn.Tanh()\n",
    "        self.softmax = nn.Softmax(dim=1)\n",
    "\n",
    "    def forward(self, query, key_value):\n",
    "        \"\"\"\n",
    "        Q K V：Q和K算出相关性得分，作为V的权重，K=V\n",
    "        参数：\n",
    "            query: 查询 (batch_size, q_dim)\n",
    "            key_value: 键和值，(batch_size, n_kv, kv_dim)\n",
    "        \"\"\"\n",
    "        # （2）计算query和key的相关性，实现注意力评分函数\n",
    "        # -> (batch_size, 1, attn_dim)\n",
    "        queries = self.attn_w_1_q(query).unsqueeze(1)\n",
    "        # -> (batch_size, n_kv, attn_dim)\n",
    "        keys = self.attn_w_1_k(key_value)\n",
    "        # -> (batch_size, n_kv)\n",
    "        attn = self.attn_w_2(self.tanh(queries+keys)).squeeze(2) \n",
    "        # （3）归一化相关性分数\n",
    "        # -> (batch_size, n_kv)\n",
    "        attn = self.softmax(attn) \n",
    "        # （4）计算输出\n",
    "        # (batch_size x 1 x n_kv)(batch_size x n_kv x kv_dim)\n",
    "        # -> (batch_size, 1, kv_dim)\n",
    "        output = torch.bmm(attn.unsqueeze(1), key_value).squeeze(1)\n",
    "        return output, attn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "解码器前馈过程的实现流程如下：\n",
    "\n",
    "（1）将图文数据按照文本的实际长度从长到短排序，这是为了模拟pack_padded_sequence函数的思想，方便后面使用动态的批大小，以避免<pad>参与运算带来的非必要的计算消耗。\n",
    "\n",
    "![pack_padded_sequence函数的作用的示例图](img/cr-pack_padded_sequence-example.png)\n",
    "    \n",
    "\n",
    "（2）在第一时刻解码前，使用图像表示来初始化GRU的隐状态。\n",
    "\n",
    "（3）解码的每一时刻的具体操作可以分解为如下4个子操作：\n",
    "    \n",
    "- （3.1）获取实际的批大小；\n",
    "\n",
    "- （3.2）利用GRU前一时刻最后一个隐藏层的状态作为查询，图像表示作为键和值，获取上下文向量；\n",
    "\n",
    "- （3.3）将上下文向量和当前时刻输入的词表示拼接起来，作为GRU该时刻的输入，获得输出；\n",
    "\n",
    "- （3.4）使用全连接层和softmax激活函数将GRU的输出映射为词表上的概率分布。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttentionDecoder(nn.Module):\n",
    "    def __init__(self, image_code_dim, vocab_size, word_dim, attention_dim, hidden_size, num_layers, dropout=0.5):\n",
    "        super(AttentionDecoder, self).__init__()\n",
    "        self.embed = nn.Embedding(vocab_size, word_dim)\n",
    "        self.attention = AdditiveAttention(hidden_size, image_code_dim, attention_dim)\n",
    "        self.init_state = nn.Linear(image_code_dim, num_layers*hidden_size)\n",
    "        self.rnn = nn.GRU(word_dim + image_code_dim, hidden_size, num_layers)\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        self.fc = nn.Linear(hidden_size, vocab_size)\n",
    "        # RNN默认已初始化\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        self.embed.weight.data.uniform_(-0.1, 0.1)\n",
    "        self.fc.bias.data.fill_(0)\n",
    "        self.fc.weight.data.uniform_(-0.1, 0.1)\n",
    "    \n",
    "    def init_hidden_state(self, image_code, captions, cap_lens):\n",
    "        \"\"\"\n",
    "        参数：\n",
    "            image_code：图像编码器输出的图像表示 \n",
    "                        (batch_size, image_code_dim, grid_height, grid_width)\n",
    "        \"\"\"\n",
    "        # 将图像网格表示转换为序列表示形式 \n",
    "        batch_size, image_code_dim = image_code.size(0), image_code.size(1)\n",
    "        # -> (batch_size, grid_height, grid_width, image_code_dim) \n",
    "        image_code = image_code.permute(0, 2, 3, 1)  \n",
    "        # -> (batch_size, grid_height * grid_width, image_code_dim)\n",
    "        image_code = image_code.view(batch_size, -1, image_code_dim)\n",
    "        # （1）按照caption的长短排序\n",
    "        sorted_cap_lens, sorted_cap_indices = torch.sort(cap_lens, 0, True)\n",
    "        captions = captions[sorted_cap_indices]\n",
    "        image_code = image_code[sorted_cap_indices]\n",
    "         #（2）初始化隐状态\n",
    "        hidden_state = self.init_state(image_code.mean(axis=1))\n",
    "        hidden_state = hidden_state.view(\n",
    "                            batch_size, \n",
    "                            self.rnn.num_layers, \n",
    "                            self.rnn.hidden_size).permute(1, 0, 2)\n",
    "        return image_code, captions, sorted_cap_lens, sorted_cap_indices, hidden_state\n",
    "\n",
    "    def forward_step(self, image_code, curr_cap_embed, hidden_state):\n",
    "        #（3.2）利用注意力机制获得上下文向量\n",
    "        # query：hidden_state[-1]，即最后一个隐藏层输出 (batch_size, hidden_size)\n",
    "        # context: (batch_size, hidden_size)\n",
    "        context, alpha = self.attention(hidden_state[-1], image_code)\n",
    "        #（3.3）以上下文向量和当前时刻词表示为输入，获得GRU输出\n",
    "        x = torch.cat((context, curr_cap_embed), dim=-1).unsqueeze(0)\n",
    "        # x: (1, real_batch_size, hidden_size+word_dim)\n",
    "        # out: (1, real_batch_size, hidden_size)\n",
    "        out, hidden_state = self.rnn(x, hidden_state)\n",
    "        #（3.4）获取该时刻的预测结果\n",
    "        # (real_batch_size, vocab_size)\n",
    "        preds = self.fc(self.dropout(out.squeeze(0)))\n",
    "        return preds, alpha, hidden_state\n",
    "        \n",
    "    def forward(self, image_code, captions, cap_lens):\n",
    "        \"\"\"\n",
    "        参数：\n",
    "            hidden_state: (num_layers, batch_size, hidden_size)\n",
    "            image_code:  (batch_size, feature_channel, feature_size)\n",
    "            captions: (batch_size, )\n",
    "        \"\"\"\n",
    "        # （1）将图文数据按照文本的实际长度从长到短排序\n",
    "        # （2）获得GRU的初始隐状态\n",
    "        image_code, captions, sorted_cap_lens, sorted_cap_indices, hidden_state \\\n",
    "            = self.init_hidden_state(image_code, captions, cap_lens)\n",
    "        batch_size = image_code.size(0)\n",
    "        # 输入序列长度减1，因为最后一个时刻不需要预测下一个词\n",
    "        lengths = sorted_cap_lens.cpu().numpy() - 1\n",
    "        # 初始化变量：模型的预测结果和注意力分数\n",
    "        predictions = torch.zeros(batch_size, lengths[0], self.fc.out_features).to(captions.device)\n",
    "        alphas = torch.zeros(batch_size, lengths[0], image_code.shape[1]).to(captions.device)\n",
    "        # 获取文本嵌入表示 cap_embeds: (batch_size, num_steps, word_dim)\n",
    "        cap_embeds = self.embed(captions)\n",
    "        # Teacher-Forcing模式\n",
    "        for step in range(lengths[0]):\n",
    "            #（3）解码\n",
    "            #（3.1）模拟pack_padded_sequence函数的原理，获取该时刻的非<pad>输入\n",
    "            real_batch_size = np.where(lengths>step)[0].shape[0]\n",
    "            preds, alpha, hidden_state = self.forward_step(\n",
    "                            image_code[:real_batch_size], \n",
    "                            cap_embeds[:real_batch_size, step, :],\n",
    "                            hidden_state[:, :real_batch_size, :].contiguous())            \n",
    "            # 记录结果\n",
    "            predictions[:real_batch_size, step, :] = preds\n",
    "            alphas[:real_batch_size, step, :] = alpha\n",
    "        return predictions, alphas, captions, lengths, sorted_cap_indices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### ARCTIC模型\n",
    "\n",
    "在定义编码器和解码器完成之后，我们就很容易构建图像描述模型ARCTIC了。仅需要在初始化函数时声明编码器和解码器，然后在前馈函数实现里，将编码器的输出和文本描述作为解码器的输入即可。\n",
    "\n",
    "这里我们额外定义了束搜索采样函数，用于生成句子，以计算BLEU值。下面的代码详细标注了其具体实现。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ARCTIC(nn.Module):\n",
    "    def __init__(self, image_code_dim, vocab, word_dim, attention_dim, hidden_size, num_layers):\n",
    "        super(ARCTIC, self).__init__()\n",
    "        self.vocab = vocab\n",
    "        self.encoder = ImageEncoder()\n",
    "        self.decoder = AttentionDecoder(image_code_dim, len(vocab), word_dim, attention_dim, hidden_size, num_layers)\n",
    "\n",
    "    def forward(self, images, captions, cap_lens):\n",
    "        image_code = self.encoder(images)\n",
    "        return self.decoder(image_code, captions, cap_lens)\n",
    "    \n",
    "    def generate_by_beamsearch(self, images, beam_k, max_len):\n",
    "        vocab_size = len(self.vocab)\n",
    "        image_codes = self.encoder(images)\n",
    "        texts = []\n",
    "        device = images.device\n",
    "        # 对每个图像样本执行束搜索\n",
    "        for image_code in image_codes:\n",
    "            # 将图像表示复制k份\n",
    "            image_code = image_code.unsqueeze(0).repeat(beam_k,1,1,1)\n",
    "            # 生成k个候选句子，初始时，仅包含开始符号<start>\n",
    "            cur_sents = torch.full((beam_k, 1), self.vocab['<start>'], dtype=torch.long).to(device)\n",
    "            cur_sent_embed = self.decoder.embed(cur_sents)[:,0,:]\n",
    "            sent_lens = torch.LongTensor([1]*beam_k).to(device)\n",
    "            # 获得GRU的初始隐状态\n",
    "            image_code, cur_sent_embed, _, _, hidden_state = \\\n",
    "                self.decoder.init_hidden_state(image_code, cur_sent_embed, sent_lens)\n",
    "            # 存储已生成完整的句子（以句子结束符<end>结尾的句子）\n",
    "            end_sents = []\n",
    "            # 存储已生成完整的句子的概率\n",
    "            end_probs = []\n",
    "            # 存储未完整生成的句子的概率\n",
    "            probs = torch.zeros(beam_k, 1).to(device)\n",
    "            k = beam_k\n",
    "            while True:\n",
    "                preds, _, hidden_state = self.decoder.forward_step(image_code[:k], cur_sent_embed, hidden_state.contiguous())\n",
    "                # -> (k, vocab_size)\n",
    "                preds = nn.functional.log_softmax(preds, dim=1)\n",
    "                # 对每个候选句子采样概率值最大的前k个单词生成k个新的候选句子，并计算概率\n",
    "                # -> (k, vocab_size)\n",
    "                probs = probs.repeat(1,preds.size(1)) + preds\n",
    "                if cur_sents.size(1) == 1:\n",
    "                    # 第一步时，所有句子都只包含开始标识符，因此，仅利用其中一个句子计算topk\n",
    "                    values, indices = probs[0].topk(k, 0, True, True)\n",
    "                else:\n",
    "                    # probs: (k, vocab_size) 是二维张量\n",
    "                    # topk函数直接应用于二维张量会按照指定维度取最大值，这里需要在全局取最大值\n",
    "                    # 因此，将probs转换为一维张量，再使用topk函数获取最大的k个值\n",
    "                    values, indices = probs.view(-1).topk(k, 0, True, True)\n",
    "                # 计算最大的k个值对应的句子索引和词索引\n",
    "                sent_indices = torch.div(indices, vocab_size, rounding_mode='trunc') \n",
    "                word_indices = indices % vocab_size \n",
    "                # 将词拼接在前一轮的句子后，获得此轮的句子\n",
    "                cur_sents = torch.cat([cur_sents[sent_indices], word_indices.unsqueeze(1)], dim=1)\n",
    "                # 查找此轮生成句子结束符<end>的句子\n",
    "                end_indices = [idx for idx, word in enumerate(word_indices) if word == self.vocab['<end>']]\n",
    "                if len(end_indices) > 0:\n",
    "                    end_probs.extend(values[end_indices])\n",
    "                    end_sents.extend(cur_sents[end_indices].tolist())\n",
    "                    # 如果所有的句子都包含结束符，则停止生成\n",
    "                    k -= len(end_indices)\n",
    "                    if k == 0:\n",
    "                        break\n",
    "                # 查找还需要继续生成词的句子\n",
    "                cur_indices = [idx for idx, word in enumerate(word_indices) \n",
    "                               if word != self.vocab['<end>']]\n",
    "                if len(cur_indices) > 0:\n",
    "                    cur_sent_indices = sent_indices[cur_indices]\n",
    "                    cur_word_indices = word_indices[cur_indices]\n",
    "                    # 仅保留还需要继续生成的句子、句子概率、隐状态、词嵌入\n",
    "                    cur_sents = cur_sents[cur_indices]\n",
    "                    probs = values[cur_indices].view(-1,1)\n",
    "                    hidden_state = hidden_state[:,cur_sent_indices,:]\n",
    "                    cur_sent_embed = self.decoder.embed(\n",
    "                        cur_word_indices.view(-1,1))[:,0,:]\n",
    "                # 句子太长，停止生成\n",
    "                if cur_sents.size(1) >= max_len:\n",
    "                    break\n",
    "            if len(end_sents) == 0:\n",
    "                # 如果没有包含结束符的句子，则选取第一个句子作为生成句子\n",
    "                gen_sent = cur_sents[0].tolist()\n",
    "            else: \n",
    "                # 否则选取包含结束符的句子中概率最大的句子\n",
    "                gen_sent = end_sents[end_probs.index(max(end_probs))]\n",
    "            texts.append(gen_sent)\n",
    "        return texts\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 定义损失函数\n",
    "\n",
    "这里采用了最常用的交叉熵损失作为损失函数。由于同一个训练批次里的文本描述的长度不一致，因此，有大量的不需要计算损失的<pad>目标。为了避免计算资源的浪费，这里先将数据按照文本长度排序，再利用pack_padded_sequence函数将预测目标为\\<pad\\>的数据去除，最后再利用交叉熵损失计算实际的损失。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PackedCrossEntropyLoss(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(PackedCrossEntropyLoss, self).__init__()\n",
    "        self.loss_fn = nn.CrossEntropyLoss()\n",
    "\n",
    "    def forward(self, predictions, targets, lengths):\n",
    "        \"\"\"\n",
    "        参数：\n",
    "            predictions：按文本长度排序过的预测结果\n",
    "            targets：按文本长度排序过的文本描述\n",
    "            lengths：文本长度\n",
    "        \"\"\"\n",
    "        predictions = pack_padded_sequence(predictions, lengths, batch_first=True)[0]\n",
    "        targets = pack_padded_sequence(targets, lengths, batch_first=True)[0]\n",
    "        return self.loss_fn(predictions, targets)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 选择优化方法\n",
    "\n",
    "这里选用Adam优化算法来更新模型参数，由于数据集较小，训练轮次少，因此，学习速率在训练过程中并不调整。但是对编码器和解码器采用了不同的学习速率。具体来说，预训练的图像编码器的学习速率小于需要从头开始训练的文本解码器的学习速率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_optimizer(model, config):\n",
    "    return torch.optim.Adam([{\"params\": filter(lambda p: p.requires_grad, model.encoder.parameters()), \n",
    "                              \"lr\": config.encoder_learning_rate},\n",
    "                             {\"params\": filter(lambda p: p.requires_grad, model.decoder.parameters()), \n",
    "                              \"lr\": config.decoder_learning_rate}])\n",
    "    \n",
    "def adjust_learning_rate(optimizer, epoch, config):\n",
    "    \"\"\"\n",
    "        每隔lr_update个轮次，学习速率减小至当前十分之一，\n",
    "        实际上，我们并未使用该函数，这里是为了展示在训练过程中调整学习速率的方法。\n",
    "    \"\"\"\n",
    "    optimizer.param_groups[0]['lr'] = config.encoder_learning_rate * (0.1 ** (epoch // config.lr_update))\n",
    "    optimizer.param_groups[1]['lr'] = config.decoder_learning_rate * (0.1 ** (epoch // config.lr_update))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 评估指标\n",
    "\n",
    "这里借助nltk库实现了图像描述中最常用的评估指标BLEU值，需要注意的是，再调用计算BLEU值之前，要先将文本中人工添加的文本开始符、结束符和占位符去掉。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.translate.bleu_score import corpus_bleu\n",
    "\n",
    "def filter_useless_words(sent, filterd_words):\n",
    "    # 去除句子中不参与BLEU值计算的符号\n",
    "    return [w for w in sent if w not in filterd_words]\n",
    "\n",
    "def evaluate(data_loader, model, config):\n",
    "    model.eval()\n",
    "    # 存储候选文本\n",
    "    cands = []\n",
    "    # 存储参考文本\n",
    "    refs = []\n",
    "    # 需要过滤的词\n",
    "    filterd_words = set({model.vocab['<start>'], model.vocab['<end>'], model.vocab['<pad>']})\n",
    "    cpi = config.captions_per_image\n",
    "    device = next(model.parameters()).device\n",
    "    for i, (imgs, caps, caplens) in enumerate(data_loader):\n",
    "        with torch.no_grad():\n",
    "            # 通过束搜索，生成候选文本\n",
    "            texts = model.generate_by_beamsearch(imgs.to(device), config.beam_k, config.max_len+2)\n",
    "            # 候选文本\n",
    "            cands.extend([filter_useless_words(text, filterd_words) for text in texts])\n",
    "            # 参考文本\n",
    "            refs.extend([filter_useless_words(cap, filterd_words) for cap in caps.tolist()])\n",
    "    # 实际上，每个候选文本对应cpi条参考文本\n",
    "    multiple_refs = []\n",
    "    for idx in range(len(refs)):\n",
    "        multiple_refs.append(refs[(idx//cpi)*cpi : (idx//cpi)*cpi+cpi])\n",
    "    # 计算BLEU-4值，corpus_bleu函数默认weights权重为(0.25,0.25,0.25,0.25)\n",
    "    # 即计算1-gram到4-gram的BLEU几何平均值\n",
    "    bleu4 = corpus_bleu(multiple_refs, cands, weights=(0.25,0.25,0.25,0.25))\n",
    "    model.train()\n",
    "    return bleu4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 训练模型\n",
    "\n",
    "训练模型过程仍然是分为读取数据、前馈计算、计算损失、更新参数、选择模型五个步骤。\n",
    "\n",
    "模型训练的具体方案为一共训练30轮，编码器和解码器的学习速率分别为0.0001和0.0005。\n",
    "\n",
    "<!-- 模型训练的具体方案为一共训练30轮，初始编码器和解码器的学习速率分别为0.0001和0.0005，每10轮将学习速率变为原数值的1/10。 -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设置模型超参数和辅助变量\n",
    "config = Namespace(\n",
    "    max_len = 30,\n",
    "    captions_per_image = 5,\n",
    "    batch_size = 32,\n",
    "    image_code_dim = 2048,\n",
    "    word_dim = 512,\n",
    "    hidden_size = 512,\n",
    "    attention_dim = 512,\n",
    "    num_layers = 1,\n",
    "    encoder_learning_rate = 0.0001,\n",
    "    decoder_learning_rate = 0.0005,\n",
    "    num_epochs = 10,\n",
    "    grad_clip = 5.0,\n",
    "    alpha_weight = 1.0,\n",
    "    evaluate_step = 900, # 每隔多少步在验证集上测试一次\n",
    "    checkpoint = None, # 如果不为None，则利用该变量路径的模型继续训练\n",
    "    best_checkpoint = '../model/ARCTIC/best_flickr8k.ckpt', # 验证集上表现最优的模型的路径\n",
    "    last_checkpoint = '../model/ARCTIC/last_flickr8k.ckpt', # 训练完成时的模型的路径\n",
    "    beam_k = 5\n",
    ")\n",
    "\n",
    "# 设置GPU信息\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '2'\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") \n",
    "\n",
    "# 数据\n",
    "data_dir = '../data/flickr8k/'\n",
    "vocab_path = '../data/flickr8k/vocab.json'\n",
    "train_loader, valid_loader, test_loader = mktrainval(data_dir, vocab_path, config.batch_size)\n",
    "\n",
    "# 模型\n",
    "with open(vocab_path, 'r') as f:\n",
    "    vocab = json.load(f)\n",
    "\n",
    "# 随机初始化 或 载入已训练的模型\n",
    "start_epoch = 0\n",
    "checkpoint = config.checkpoint\n",
    "if checkpoint is None:\n",
    "    model = ARCTIC(config.image_code_dim, vocab, config.word_dim, config.attention_dim, config.hidden_size, config.num_layers)\n",
    "else:\n",
    "    checkpoint = torch.load(checkpoint)\n",
    "    start_epoch = checkpoint['epoch'] + 1\n",
    "    model = checkpoint['model']\n",
    "\n",
    "# 优化器\n",
    "optimizer = get_optimizer(model, config)\n",
    "\n",
    "# 将模型拷贝至GPU，并开启训练模式\n",
    "model.to(device)\n",
    "model.train()\n",
    "\n",
    "# 损失函数\n",
    "loss_fn = PackedCrossEntropyLoss().to(device)\n",
    "\n",
    "best_res = 0\n",
    "print(\"开始训练\")\n",
    "fw = open('log.txt', 'w')\n",
    "\n",
    "for epoch in range(start_epoch, config.num_epochs):\n",
    "    for i, (imgs, caps, caplens) in enumerate(train_loader):\n",
    "        optimizer.zero_grad()\n",
    "        # 1. 读取数据至GPU\n",
    "        imgs = imgs.to(device)\n",
    "        caps = caps.to(device)\n",
    "        caplens = caplens.to(device)\n",
    "\n",
    "        # 2. 前馈计算\n",
    "        predictions, alphas, sorted_captions, lengths, sorted_cap_indices = model(imgs, caps, caplens)\n",
    "        # 3. 计算损失\n",
    "        # captions从第2个词开始为targets\n",
    "        loss = loss_fn(predictions, sorted_captions[:, 1:], lengths)\n",
    "        # 重随机注意力正则项，使得模型尽可能全面的利用到每个网格\n",
    "        # 要求所有时刻在同一个网格上的注意力分数的平方和接近1\n",
    "        loss += config.alpha_weight * ((1. - alphas.sum(axis=1)) ** 2).mean()\n",
    "\n",
    "        loss.backward()\n",
    "        # 梯度截断\n",
    "        if config.grad_clip > 0:\n",
    "            nn.utils.clip_grad_norm_(model.parameters(), config.grad_clip)\n",
    "        \n",
    "        # 4. 更新参数\n",
    "        optimizer.step()\n",
    "        \n",
    "        if (i+1) % 100 == 0:\n",
    "            print('epoch %d, step %d: loss=%.2f' % (epoch, i+1, loss.cpu()))\n",
    "            fw.write('epoch %d, step %d: loss=%.2f \\n' % (epoch, i+1, loss.cpu()))\n",
    "            fw.flush()\n",
    "\n",
    "        state = {\n",
    "                'epoch': epoch,\n",
    "                'step': i,\n",
    "                'model': model,\n",
    "                'optimizer': optimizer\n",
    "                }\n",
    "        if (i+1) % config.evaluate_step == 0:\n",
    "            bleu_score = evaluate(valid_loader, model, config)\n",
    "            # 5. 选择模型\n",
    "            if best_res < bleu_score:\n",
    "                best_res = bleu_score\n",
    "                torch.save(state, config.best_checkpoint)\n",
    "            torch.save(state, config.last_checkpoint)\n",
    "            fw.write('Validation@epoch, %d, step, %d, BLEU-4=%.2f\\n' % \n",
    "                  (epoch, i+1, bleu_score))\n",
    "            fw.flush()\n",
    "            print('Validation@epoch, %d, step, %d, BLEU-4=%.2f' % \n",
    "                  (epoch, i+1, bleu_score))\n",
    "checkpoint = torch.load(config.best_checkpoint)\n",
    "model = checkpoint['model']\n",
    "bleu_score = evaluate(test_loader, model, config)\n",
    "print(\"Evaluate on the test set with the model that has the best performance on the validation set\")\n",
    "print('Epoch: %d, BLEU-4=%.2f' % \n",
    "      (checkpoint['epoch'], bleu_score))\n",
    "fw.write('Epoch: %d, BLEU-4=%.2f' % \n",
    "      (checkpoint['epoch'], bleu_score))\n",
    "fw.close()      \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码完成训练，最后一行会输出在验证集上表现最好的模型在测试集上的结果，具体如下：\n",
    "\n",
    "```\n",
    "Epoch: 4, BLEU-4=0.23\n",
    "```\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  },
  "rise": {
   "enable_chalkboard": true,
   "scroll": true
  },
  "vscode": {
   "interpreter": {
    "hash": "9c90bab175f6ebea40ddbaa491ed6726e7c53d0208272849c54b7fb296566795"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
